// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: xla/xla.proto
// Protobuf C++ Version: 5.28.3

#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 5028003
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.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 "google/protobuf/any.pb.h"
#include "xla/service/hlo.pb.h"
#include "xla/xla_data.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_xla_2fxla_2eproto PROTOBUF_EXPORT

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct PROTOBUF_EXPORT TableStruct_xla_2fxla_2eproto {
  static const ::uint32_t offsets[];
};
PROTOBUF_EXPORT extern const ::google::protobuf::internal::DescriptorTable
    descriptor_table_xla_2fxla_2eproto;
namespace xla {
class CompilationEnvironmentsProto;
struct CompilationEnvironmentsProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern CompilationEnvironmentsProtoDefaultTypeInternal _CompilationEnvironmentsProto_default_instance_;
class DebugOptions;
struct DebugOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern DebugOptionsDefaultTypeInternal _DebugOptions_default_instance_;
class DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse;
struct DebugOptions_XlaBackendExtraOptionsEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern DebugOptions_XlaBackendExtraOptionsEntry_DoNotUseDefaultTypeInternal _DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse_default_instance_;
class DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse;
struct DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUseDefaultTypeInternal _DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse_default_instance_;
class ExecutionOptions;
struct ExecutionOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern ExecutionOptionsDefaultTypeInternal _ExecutionOptions_default_instance_;
class GpuCompilationEnvironment;
struct GpuCompilationEnvironmentDefaultTypeInternal;
PROTOBUF_EXPORT extern GpuCompilationEnvironmentDefaultTypeInternal _GpuCompilationEnvironment_default_instance_;
class HloModuleConfigProto;
struct HloModuleConfigProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProtoDefaultTypeInternal _HloModuleConfigProto_default_instance_;
class HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse;
struct HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUseDefaultTypeInternal _HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse_default_instance_;
class HloModuleConfigProto_BoolList;
struct HloModuleConfigProto_BoolListDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProto_BoolListDefaultTypeInternal _HloModuleConfigProto_BoolList_default_instance_;
class HloModuleConfigProto_DotConfigEntry_DoNotUse;
struct HloModuleConfigProto_DotConfigEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProto_DotConfigEntry_DoNotUseDefaultTypeInternal _HloModuleConfigProto_DotConfigEntry_DoNotUse_default_instance_;
class HloModuleConfigProto_Int64List;
struct HloModuleConfigProto_Int64ListDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProto_Int64ListDefaultTypeInternal _HloModuleConfigProto_Int64List_default_instance_;
class HloModuleConfigProto_Int64ListList;
struct HloModuleConfigProto_Int64ListListDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleConfigProto_Int64ListListDefaultTypeInternal _HloModuleConfigProto_Int64ListList_default_instance_;
class HloModuleProtoWithConfig;
struct HloModuleProtoWithConfigDefaultTypeInternal;
PROTOBUF_EXPORT extern HloModuleProtoWithConfigDefaultTypeInternal _HloModuleProtoWithConfig_default_instance_;
class NodeShardingConfigProto;
struct NodeShardingConfigProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern NodeShardingConfigProtoDefaultTypeInternal _NodeShardingConfigProto_default_instance_;
class ScheduleConfigProto;
struct ScheduleConfigProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleConfigProtoDefaultTypeInternal _ScheduleConfigProto_default_instance_;
class ScheduleConfigProto_Instruction;
struct ScheduleConfigProto_InstructionDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleConfigProto_InstructionDefaultTypeInternal _ScheduleConfigProto_Instruction_default_instance_;
class ScheduleProto;
struct ScheduleProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleProtoDefaultTypeInternal _ScheduleProto_default_instance_;
class ScheduleProto_ComputationScheduleProto;
struct ScheduleProto_ComputationScheduleProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleProto_ComputationScheduleProtoDefaultTypeInternal _ScheduleProto_ComputationScheduleProto_default_instance_;
class ScheduleProto_Instruction;
struct ScheduleProto_InstructionDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleProto_InstructionDefaultTypeInternal _ScheduleProto_Instruction_default_instance_;
class ScheduleProto_SchedulerStatisticsProto;
struct ScheduleProto_SchedulerStatisticsProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ScheduleProto_SchedulerStatisticsProtoDefaultTypeInternal _ScheduleProto_SchedulerStatisticsProto_default_instance_;
class ShardableValueUpdatePairProto;
struct ShardableValueUpdatePairProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ShardableValueUpdatePairProtoDefaultTypeInternal _ShardableValueUpdatePairProto_default_instance_;
class ShardingConfigProto;
struct ShardingConfigProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ShardingConfigProtoDefaultTypeInternal _ShardingConfigProto_default_instance_;
}  // namespace xla
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace xla {
enum DebugOptions_CollectiveOpType : int {
  DebugOptions_CollectiveOpType_NOOP = 0,
  DebugOptions_CollectiveOpType_ALLREDUCE = 1,
  DebugOptions_CollectiveOpType_ALLGATHER = 2,
  DebugOptions_CollectiveOpType_REDUCESCATTER = 3,
  DebugOptions_CollectiveOpType_COLLECTIVEBROADCAST = 4,
  DebugOptions_CollectiveOpType_ALLTOALL = 5,
  DebugOptions_CollectiveOpType_COLLECTIVEPERMUTE = 6,
  DebugOptions_CollectiveOpType_RAGGEDALLTOALL = 7,
  DebugOptions_CollectiveOpType_ALLCOLLECTIVES = 8,
  DebugOptions_CollectiveOpType_DebugOptions_CollectiveOpType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_CollectiveOpType_DebugOptions_CollectiveOpType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_CollectiveOpType_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_CollectiveOpType_internal_data_[];
constexpr DebugOptions_CollectiveOpType DebugOptions_CollectiveOpType_CollectiveOpType_MIN = static_cast<DebugOptions_CollectiveOpType>(0);
constexpr DebugOptions_CollectiveOpType DebugOptions_CollectiveOpType_CollectiveOpType_MAX = static_cast<DebugOptions_CollectiveOpType>(8);
constexpr int DebugOptions_CollectiveOpType_CollectiveOpType_ARRAYSIZE = 8 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_CollectiveOpType_descriptor();
template <typename T>
const std::string& DebugOptions_CollectiveOpType_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_CollectiveOpType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CollectiveOpType_Name().");
  return DebugOptions_CollectiveOpType_Name(static_cast<DebugOptions_CollectiveOpType>(value));
}
template <>
inline const std::string& DebugOptions_CollectiveOpType_Name(DebugOptions_CollectiveOpType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_CollectiveOpType_descriptor,
                                                 0, 8>(
      static_cast<int>(value));
}
inline bool DebugOptions_CollectiveOpType_Parse(absl::string_view name, DebugOptions_CollectiveOpType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_CollectiveOpType>(
      DebugOptions_CollectiveOpType_descriptor(), name, value);
}
enum DebugOptions_CommandBufferCmdType : int {
  DebugOptions_CommandBufferCmdType_INVALID = 0,
  DebugOptions_CommandBufferCmdType_FUSION = 1,
  DebugOptions_CommandBufferCmdType_CUBLAS = 2,
  DebugOptions_CommandBufferCmdType_CUDNN = 3,
  DebugOptions_CommandBufferCmdType_COLLECTIVES = 4,
  DebugOptions_CommandBufferCmdType_CONDITIONAL = 5,
  DebugOptions_CommandBufferCmdType_WHILE = 6,
  DebugOptions_CommandBufferCmdType_CUSTOM_CALL = 7,
  DebugOptions_CommandBufferCmdType_CUBLASLT = 8,
  DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_FUSION = 9,
  DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_COPY_FUSION = 10,
  DebugOptions_CommandBufferCmdType_DebugOptions_CommandBufferCmdType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_CommandBufferCmdType_DebugOptions_CommandBufferCmdType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_CommandBufferCmdType_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_CommandBufferCmdType_internal_data_[];
constexpr DebugOptions_CommandBufferCmdType DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MIN = static_cast<DebugOptions_CommandBufferCmdType>(0);
constexpr DebugOptions_CommandBufferCmdType DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MAX = static_cast<DebugOptions_CommandBufferCmdType>(10);
constexpr int DebugOptions_CommandBufferCmdType_CommandBufferCmdType_ARRAYSIZE = 10 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_CommandBufferCmdType_descriptor();
template <typename T>
const std::string& DebugOptions_CommandBufferCmdType_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_CommandBufferCmdType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CommandBufferCmdType_Name().");
  return DebugOptions_CommandBufferCmdType_Name(static_cast<DebugOptions_CommandBufferCmdType>(value));
}
template <>
inline const std::string& DebugOptions_CommandBufferCmdType_Name(DebugOptions_CommandBufferCmdType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_CommandBufferCmdType_descriptor,
                                                 0, 10>(
      static_cast<int>(value));
}
inline bool DebugOptions_CommandBufferCmdType_Parse(absl::string_view name, DebugOptions_CommandBufferCmdType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_CommandBufferCmdType>(
      DebugOptions_CommandBufferCmdType_descriptor(), name, value);
}
enum DebugOptions_LibNvJitLinkMode : int {
  DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_AUTO = 0,
  DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_DISABLED = 1,
  DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_ENABLED = 2,
  DebugOptions_LibNvJitLinkMode_DebugOptions_LibNvJitLinkMode_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_LibNvJitLinkMode_DebugOptions_LibNvJitLinkMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_LibNvJitLinkMode_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_LibNvJitLinkMode_internal_data_[];
constexpr DebugOptions_LibNvJitLinkMode DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MIN = static_cast<DebugOptions_LibNvJitLinkMode>(0);
constexpr DebugOptions_LibNvJitLinkMode DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MAX = static_cast<DebugOptions_LibNvJitLinkMode>(2);
constexpr int DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_LibNvJitLinkMode_descriptor();
template <typename T>
const std::string& DebugOptions_LibNvJitLinkMode_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_LibNvJitLinkMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LibNvJitLinkMode_Name().");
  return DebugOptions_LibNvJitLinkMode_Name(static_cast<DebugOptions_LibNvJitLinkMode>(value));
}
template <>
inline const std::string& DebugOptions_LibNvJitLinkMode_Name(DebugOptions_LibNvJitLinkMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_LibNvJitLinkMode_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool DebugOptions_LibNvJitLinkMode_Parse(absl::string_view name, DebugOptions_LibNvJitLinkMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_LibNvJitLinkMode>(
      DebugOptions_LibNvJitLinkMode_descriptor(), name, value);
}
enum DebugOptions_PGLEStrictnessLevel : int {
  DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_OFF = 0,
  DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_WARN = 1,
  DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_ERROR = 2,
  DebugOptions_PGLEStrictnessLevel_DebugOptions_PGLEStrictnessLevel_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_PGLEStrictnessLevel_DebugOptions_PGLEStrictnessLevel_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_PGLEStrictnessLevel_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_PGLEStrictnessLevel_internal_data_[];
constexpr DebugOptions_PGLEStrictnessLevel DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MIN = static_cast<DebugOptions_PGLEStrictnessLevel>(0);
constexpr DebugOptions_PGLEStrictnessLevel DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MAX = static_cast<DebugOptions_PGLEStrictnessLevel>(2);
constexpr int DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_PGLEStrictnessLevel_descriptor();
template <typename T>
const std::string& DebugOptions_PGLEStrictnessLevel_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_PGLEStrictnessLevel>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PGLEStrictnessLevel_Name().");
  return DebugOptions_PGLEStrictnessLevel_Name(static_cast<DebugOptions_PGLEStrictnessLevel>(value));
}
template <>
inline const std::string& DebugOptions_PGLEStrictnessLevel_Name(DebugOptions_PGLEStrictnessLevel value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_PGLEStrictnessLevel_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool DebugOptions_PGLEStrictnessLevel_Parse(absl::string_view name, DebugOptions_PGLEStrictnessLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_PGLEStrictnessLevel>(
      DebugOptions_PGLEStrictnessLevel_descriptor(), name, value);
}
enum DebugOptions_ShapeChecks : int {
  DebugOptions_ShapeChecks_IGNORE = 0,
  DebugOptions_ShapeChecks_RUNTIME = 1,
  DebugOptions_ShapeChecks_COMPILE_TIME = 2,
  DebugOptions_ShapeChecks_DebugOptions_ShapeChecks_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_ShapeChecks_DebugOptions_ShapeChecks_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_ShapeChecks_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_ShapeChecks_internal_data_[];
constexpr DebugOptions_ShapeChecks DebugOptions_ShapeChecks_ShapeChecks_MIN = static_cast<DebugOptions_ShapeChecks>(0);
constexpr DebugOptions_ShapeChecks DebugOptions_ShapeChecks_ShapeChecks_MAX = static_cast<DebugOptions_ShapeChecks>(2);
constexpr int DebugOptions_ShapeChecks_ShapeChecks_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_ShapeChecks_descriptor();
template <typename T>
const std::string& DebugOptions_ShapeChecks_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_ShapeChecks>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ShapeChecks_Name().");
  return DebugOptions_ShapeChecks_Name(static_cast<DebugOptions_ShapeChecks>(value));
}
template <>
inline const std::string& DebugOptions_ShapeChecks_Name(DebugOptions_ShapeChecks value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_ShapeChecks_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool DebugOptions_ShapeChecks_Parse(absl::string_view name, DebugOptions_ShapeChecks* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_ShapeChecks>(
      DebugOptions_ShapeChecks_descriptor(), name, value);
}
enum DebugOptions_WhileLoopUnrolling : int {
  DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_NO_UNROLL = 0,
  DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_DOUBLE_BUFFER = 1,
  DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_FULL_UNROLL = 2,
  DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_AUTO_UNROLL = 3,
  DebugOptions_WhileLoopUnrolling_DebugOptions_WhileLoopUnrolling_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_WhileLoopUnrolling_DebugOptions_WhileLoopUnrolling_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_WhileLoopUnrolling_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_WhileLoopUnrolling_internal_data_[];
constexpr DebugOptions_WhileLoopUnrolling DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MIN = static_cast<DebugOptions_WhileLoopUnrolling>(0);
constexpr DebugOptions_WhileLoopUnrolling DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MAX = static_cast<DebugOptions_WhileLoopUnrolling>(3);
constexpr int DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_WhileLoopUnrolling_descriptor();
template <typename T>
const std::string& DebugOptions_WhileLoopUnrolling_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_WhileLoopUnrolling>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to WhileLoopUnrolling_Name().");
  return DebugOptions_WhileLoopUnrolling_Name(static_cast<DebugOptions_WhileLoopUnrolling>(value));
}
template <>
inline const std::string& DebugOptions_WhileLoopUnrolling_Name(DebugOptions_WhileLoopUnrolling value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_WhileLoopUnrolling_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool DebugOptions_WhileLoopUnrolling_Parse(absl::string_view name, DebugOptions_WhileLoopUnrolling* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_WhileLoopUnrolling>(
      DebugOptions_WhileLoopUnrolling_descriptor(), name, value);
}
enum DebugOptions_XnnGraphFusionMode : int {
  DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_DISABLED = 0,
  DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY = 1,
  DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY_SLINKY = 2,
  DebugOptions_XnnGraphFusionMode_DebugOptions_XnnGraphFusionMode_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_XnnGraphFusionMode_DebugOptions_XnnGraphFusionMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_XnnGraphFusionMode_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_XnnGraphFusionMode_internal_data_[];
constexpr DebugOptions_XnnGraphFusionMode DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MIN = static_cast<DebugOptions_XnnGraphFusionMode>(0);
constexpr DebugOptions_XnnGraphFusionMode DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MAX = static_cast<DebugOptions_XnnGraphFusionMode>(2);
constexpr int DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_XnnGraphFusionMode_descriptor();
template <typename T>
const std::string& DebugOptions_XnnGraphFusionMode_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_XnnGraphFusionMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to XnnGraphFusionMode_Name().");
  return DebugOptions_XnnGraphFusionMode_Name(static_cast<DebugOptions_XnnGraphFusionMode>(value));
}
template <>
inline const std::string& DebugOptions_XnnGraphFusionMode_Name(DebugOptions_XnnGraphFusionMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_XnnGraphFusionMode_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool DebugOptions_XnnGraphFusionMode_Parse(absl::string_view name, DebugOptions_XnnGraphFusionMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_XnnGraphFusionMode>(
      DebugOptions_XnnGraphFusionMode_descriptor(), name, value);
}
enum DebugOptions_GenericTritonEmitterFeature : int {
  DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_UNSPECIFIED = 0,
  DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ENABLE_NESTED_GEMM = 1,
  DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_DISABLE_LEGACY_GEMM = 2,
  DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ALLOW_ALL_OPS_IN_GEMM_FUSION = 3,
  DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ALLOW_ALL_GEMM_SHAPES = 4,
  DebugOptions_GenericTritonEmitterFeature_DebugOptions_GenericTritonEmitterFeature_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_GenericTritonEmitterFeature_DebugOptions_GenericTritonEmitterFeature_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_GenericTritonEmitterFeature_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_GenericTritonEmitterFeature_internal_data_[];
constexpr DebugOptions_GenericTritonEmitterFeature DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_MIN = static_cast<DebugOptions_GenericTritonEmitterFeature>(0);
constexpr DebugOptions_GenericTritonEmitterFeature DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_MAX = static_cast<DebugOptions_GenericTritonEmitterFeature>(4);
constexpr int DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_ARRAYSIZE = 4 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_GenericTritonEmitterFeature_descriptor();
template <typename T>
const std::string& DebugOptions_GenericTritonEmitterFeature_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_GenericTritonEmitterFeature>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to GenericTritonEmitterFeature_Name().");
  return DebugOptions_GenericTritonEmitterFeature_Name(static_cast<DebugOptions_GenericTritonEmitterFeature>(value));
}
template <>
inline const std::string& DebugOptions_GenericTritonEmitterFeature_Name(DebugOptions_GenericTritonEmitterFeature value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_GenericTritonEmitterFeature_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool DebugOptions_GenericTritonEmitterFeature_Parse(absl::string_view name, DebugOptions_GenericTritonEmitterFeature* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_GenericTritonEmitterFeature>(
      DebugOptions_GenericTritonEmitterFeature_descriptor(), name, value);
}
enum DebugOptions_PipelineParallelismOptLevel : int {
  DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE = 0,
  DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE = 1,
  DebugOptions_PipelineParallelismOptLevel_DebugOptions_PipelineParallelismOptLevel_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_PipelineParallelismOptLevel_DebugOptions_PipelineParallelismOptLevel_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_PipelineParallelismOptLevel_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_PipelineParallelismOptLevel_internal_data_[];
constexpr DebugOptions_PipelineParallelismOptLevel DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MIN = static_cast<DebugOptions_PipelineParallelismOptLevel>(0);
constexpr DebugOptions_PipelineParallelismOptLevel DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MAX = static_cast<DebugOptions_PipelineParallelismOptLevel>(1);
constexpr int DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_ARRAYSIZE = 1 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_PipelineParallelismOptLevel_descriptor();
template <typename T>
const std::string& DebugOptions_PipelineParallelismOptLevel_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_PipelineParallelismOptLevel>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PipelineParallelismOptLevel_Name().");
  return DebugOptions_PipelineParallelismOptLevel_Name(static_cast<DebugOptions_PipelineParallelismOptLevel>(value));
}
template <>
inline const std::string& DebugOptions_PipelineParallelismOptLevel_Name(DebugOptions_PipelineParallelismOptLevel value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_PipelineParallelismOptLevel_descriptor,
                                                 0, 1>(
      static_cast<int>(value));
}
inline bool DebugOptions_PipelineParallelismOptLevel_Parse(absl::string_view name, DebugOptions_PipelineParallelismOptLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_PipelineParallelismOptLevel>(
      DebugOptions_PipelineParallelismOptLevel_descriptor(), name, value);
}
enum DebugOptions_StepMarkerLocation : int {
  DebugOptions_StepMarkerLocation_STEP_MARK_AT_ENTRY = 0,
  DebugOptions_StepMarkerLocation_STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP = 1,
  DebugOptions_StepMarkerLocation_STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP = 3,
  DebugOptions_StepMarkerLocation_STEP_MARK_NONE = 2,
  DebugOptions_StepMarkerLocation_DebugOptions_StepMarkerLocation_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_StepMarkerLocation_DebugOptions_StepMarkerLocation_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_StepMarkerLocation_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_StepMarkerLocation_internal_data_[];
constexpr DebugOptions_StepMarkerLocation DebugOptions_StepMarkerLocation_StepMarkerLocation_MIN = static_cast<DebugOptions_StepMarkerLocation>(0);
constexpr DebugOptions_StepMarkerLocation DebugOptions_StepMarkerLocation_StepMarkerLocation_MAX = static_cast<DebugOptions_StepMarkerLocation>(3);
constexpr int DebugOptions_StepMarkerLocation_StepMarkerLocation_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_StepMarkerLocation_descriptor();
template <typename T>
const std::string& DebugOptions_StepMarkerLocation_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_StepMarkerLocation>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to StepMarkerLocation_Name().");
  return DebugOptions_StepMarkerLocation_Name(static_cast<DebugOptions_StepMarkerLocation>(value));
}
template <>
inline const std::string& DebugOptions_StepMarkerLocation_Name(DebugOptions_StepMarkerLocation value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_StepMarkerLocation_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool DebugOptions_StepMarkerLocation_Parse(absl::string_view name, DebugOptions_StepMarkerLocation* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_StepMarkerLocation>(
      DebugOptions_StepMarkerLocation_descriptor(), name, value);
}
enum DebugOptions_PartitioningAlgorithm : int {
  DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_NOOP = 0,
  DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP0 = 1,
  DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP1 = 2,
  DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP2 = 3,
  DebugOptions_PartitioningAlgorithm_DebugOptions_PartitioningAlgorithm_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_PartitioningAlgorithm_DebugOptions_PartitioningAlgorithm_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_PartitioningAlgorithm_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_PartitioningAlgorithm_internal_data_[];
constexpr DebugOptions_PartitioningAlgorithm DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MIN = static_cast<DebugOptions_PartitioningAlgorithm>(0);
constexpr DebugOptions_PartitioningAlgorithm DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MAX = static_cast<DebugOptions_PartitioningAlgorithm>(3);
constexpr int DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_PartitioningAlgorithm_descriptor();
template <typename T>
const std::string& DebugOptions_PartitioningAlgorithm_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_PartitioningAlgorithm>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PartitioningAlgorithm_Name().");
  return DebugOptions_PartitioningAlgorithm_Name(static_cast<DebugOptions_PartitioningAlgorithm>(value));
}
template <>
inline const std::string& DebugOptions_PartitioningAlgorithm_Name(DebugOptions_PartitioningAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_PartitioningAlgorithm_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool DebugOptions_PartitioningAlgorithm_Parse(absl::string_view name, DebugOptions_PartitioningAlgorithm* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_PartitioningAlgorithm>(
      DebugOptions_PartitioningAlgorithm_descriptor(), name, value);
}
enum DebugOptions_AutotuneCacheMode : int {
  DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UNSPECIFIED = 0,
  DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UPDATE = 1,
  DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_READ = 2,
  DebugOptions_AutotuneCacheMode_DebugOptions_AutotuneCacheMode_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  DebugOptions_AutotuneCacheMode_DebugOptions_AutotuneCacheMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool DebugOptions_AutotuneCacheMode_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t DebugOptions_AutotuneCacheMode_internal_data_[];
constexpr DebugOptions_AutotuneCacheMode DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MIN = static_cast<DebugOptions_AutotuneCacheMode>(0);
constexpr DebugOptions_AutotuneCacheMode DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MAX = static_cast<DebugOptions_AutotuneCacheMode>(2);
constexpr int DebugOptions_AutotuneCacheMode_AutotuneCacheMode_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
DebugOptions_AutotuneCacheMode_descriptor();
template <typename T>
const std::string& DebugOptions_AutotuneCacheMode_Name(T value) {
  static_assert(std::is_same<T, DebugOptions_AutotuneCacheMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AutotuneCacheMode_Name().");
  return DebugOptions_AutotuneCacheMode_Name(static_cast<DebugOptions_AutotuneCacheMode>(value));
}
template <>
inline const std::string& DebugOptions_AutotuneCacheMode_Name(DebugOptions_AutotuneCacheMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DebugOptions_AutotuneCacheMode_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool DebugOptions_AutotuneCacheMode_Parse(absl::string_view name, DebugOptions_AutotuneCacheMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DebugOptions_AutotuneCacheMode>(
      DebugOptions_AutotuneCacheMode_descriptor(), name, value);
}
enum ExecutionOptions_EffortLevel : int {
  ExecutionOptions_EffortLevel_EFFORT_UNKNOWN = 0,
  ExecutionOptions_EffortLevel_EFFORT_O0 = 9,
  ExecutionOptions_EffortLevel_EFFORT_O1 = 19,
  ExecutionOptions_EffortLevel_EFFORT_O2 = 29,
  ExecutionOptions_EffortLevel_EFFORT_O3 = 39,
  ExecutionOptions_EffortLevel_ExecutionOptions_EffortLevel_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  ExecutionOptions_EffortLevel_ExecutionOptions_EffortLevel_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool ExecutionOptions_EffortLevel_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t ExecutionOptions_EffortLevel_internal_data_[];
constexpr ExecutionOptions_EffortLevel ExecutionOptions_EffortLevel_EffortLevel_MIN = static_cast<ExecutionOptions_EffortLevel>(0);
constexpr ExecutionOptions_EffortLevel ExecutionOptions_EffortLevel_EffortLevel_MAX = static_cast<ExecutionOptions_EffortLevel>(39);
constexpr int ExecutionOptions_EffortLevel_EffortLevel_ARRAYSIZE = 39 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
ExecutionOptions_EffortLevel_descriptor();
template <typename T>
const std::string& ExecutionOptions_EffortLevel_Name(T value) {
  static_assert(std::is_same<T, ExecutionOptions_EffortLevel>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to EffortLevel_Name().");
  return ::google::protobuf::internal::NameOfEnum(ExecutionOptions_EffortLevel_descriptor(), value);
}
inline bool ExecutionOptions_EffortLevel_Parse(absl::string_view name, ExecutionOptions_EffortLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ExecutionOptions_EffortLevel>(
      ExecutionOptions_EffortLevel_descriptor(), name, value);
}
enum HloModuleConfigProto_FusionConfigCollection : int {
  HloModuleConfigProto_FusionConfigCollection_OFF = 0,
  HloModuleConfigProto_FusionConfigCollection_PER_EDGE = 1,
  HloModuleConfigProto_FusionConfigCollection_PER_NODE = 2,
  HloModuleConfigProto_FusionConfigCollection_HloModuleConfigProto_FusionConfigCollection_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  HloModuleConfigProto_FusionConfigCollection_HloModuleConfigProto_FusionConfigCollection_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool HloModuleConfigProto_FusionConfigCollection_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t HloModuleConfigProto_FusionConfigCollection_internal_data_[];
constexpr HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MIN = static_cast<HloModuleConfigProto_FusionConfigCollection>(0);
constexpr HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MAX = static_cast<HloModuleConfigProto_FusionConfigCollection>(2);
constexpr int HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_ARRAYSIZE = 2 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
HloModuleConfigProto_FusionConfigCollection_descriptor();
template <typename T>
const std::string& HloModuleConfigProto_FusionConfigCollection_Name(T value) {
  static_assert(std::is_same<T, HloModuleConfigProto_FusionConfigCollection>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to FusionConfigCollection_Name().");
  return HloModuleConfigProto_FusionConfigCollection_Name(static_cast<HloModuleConfigProto_FusionConfigCollection>(value));
}
template <>
inline const std::string& HloModuleConfigProto_FusionConfigCollection_Name(HloModuleConfigProto_FusionConfigCollection value) {
  return ::google::protobuf::internal::NameOfDenseEnum<HloModuleConfigProto_FusionConfigCollection_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool HloModuleConfigProto_FusionConfigCollection_Parse(absl::string_view name, HloModuleConfigProto_FusionConfigCollection* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HloModuleConfigProto_FusionConfigCollection>(
      HloModuleConfigProto_FusionConfigCollection_descriptor(), name, value);
}

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


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

class PROTOBUF_EXPORT ShardableValueUpdatePairProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ShardableValueUpdatePairProto) */ {
 public:
  inline ShardableValueUpdatePairProto() : ShardableValueUpdatePairProto(nullptr) {}
  ~ShardableValueUpdatePairProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ShardableValueUpdatePairProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ShardableValueUpdatePairProto(const ShardableValueUpdatePairProto& from) : ShardableValueUpdatePairProto(nullptr, from) {}
  inline ShardableValueUpdatePairProto(ShardableValueUpdatePairProto&& from) noexcept
      : ShardableValueUpdatePairProto(nullptr, std::move(from)) {}
  inline ShardableValueUpdatePairProto& operator=(const ShardableValueUpdatePairProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShardableValueUpdatePairProto& operator=(ShardableValueUpdatePairProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ShardableValueUpdatePairProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ShardableValueUpdatePairProto* internal_default_instance() {
    return reinterpret_cast<const ShardableValueUpdatePairProto*>(
        &_ShardableValueUpdatePairProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(ShardableValueUpdatePairProto& a, ShardableValueUpdatePairProto& b) { a.Swap(&b); }
  inline void Swap(ShardableValueUpdatePairProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ShardableValueUpdatePairProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ShardableValueUpdatePairProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ShardableValueUpdatePairProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ShardableValueUpdatePairProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ShardableValueUpdatePairProto& from) { ShardableValueUpdatePairProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ShardableValueUpdatePairProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ShardableValueUpdatePairProto"; }

 protected:
  explicit ShardableValueUpdatePairProto(::google::protobuf::Arena* arena);
  ShardableValueUpdatePairProto(::google::protobuf::Arena* arena, const ShardableValueUpdatePairProto& from);
  ShardableValueUpdatePairProto(::google::protobuf::Arena* arena, ShardableValueUpdatePairProto&& from) noexcept
      : ShardableValueUpdatePairProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kParameterShapeIndexFieldNumber = 2,
    kOutputShapeIndexFieldNumber = 3,
    kInputParameterNumberFieldNumber = 1,
  };
  // repeated int64 parameter_shape_index = 2;
  int parameter_shape_index_size() const;
  private:
  int _internal_parameter_shape_index_size() const;

  public:
  void clear_parameter_shape_index() ;
  ::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 ::google::protobuf::RepeatedField<::int64_t>& parameter_shape_index() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_parameter_shape_index();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_parameter_shape_index() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_parameter_shape_index();

  public:
  // repeated int64 output_shape_index = 3;
  int output_shape_index_size() const;
  private:
  int _internal_output_shape_index_size() const;

  public:
  void clear_output_shape_index() ;
  ::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 ::google::protobuf::RepeatedField<::int64_t>& output_shape_index() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_output_shape_index();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_output_shape_index() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_output_shape_index();

  public:
  // int64 input_parameter_number = 1;
  void clear_input_parameter_number() ;
  ::int64_t input_parameter_number() const;
  void set_input_parameter_number(::int64_t value);

  private:
  ::int64_t _internal_input_parameter_number() const;
  void _internal_set_input_parameter_number(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.ShardableValueUpdatePairProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ShardableValueUpdatePairProto& from_msg);
    ::google::protobuf::RepeatedField<::int64_t> parameter_shape_index_;
    mutable ::google::protobuf::internal::CachedSize _parameter_shape_index_cached_byte_size_;
    ::google::protobuf::RepeatedField<::int64_t> output_shape_index_;
    mutable ::google::protobuf::internal::CachedSize _output_shape_index_cached_byte_size_;
    ::int64_t input_parameter_number_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleProto_SchedulerStatisticsProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleProto.SchedulerStatisticsProto) */ {
 public:
  inline ScheduleProto_SchedulerStatisticsProto() : ScheduleProto_SchedulerStatisticsProto(nullptr) {}
  ~ScheduleProto_SchedulerStatisticsProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleProto_SchedulerStatisticsProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleProto_SchedulerStatisticsProto(const ScheduleProto_SchedulerStatisticsProto& from) : ScheduleProto_SchedulerStatisticsProto(nullptr, from) {}
  inline ScheduleProto_SchedulerStatisticsProto(ScheduleProto_SchedulerStatisticsProto&& from) noexcept
      : ScheduleProto_SchedulerStatisticsProto(nullptr, std::move(from)) {}
  inline ScheduleProto_SchedulerStatisticsProto& operator=(const ScheduleProto_SchedulerStatisticsProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleProto_SchedulerStatisticsProto& operator=(ScheduleProto_SchedulerStatisticsProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleProto_SchedulerStatisticsProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleProto_SchedulerStatisticsProto* internal_default_instance() {
    return reinterpret_cast<const ScheduleProto_SchedulerStatisticsProto*>(
        &_ScheduleProto_SchedulerStatisticsProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 15;
  friend void swap(ScheduleProto_SchedulerStatisticsProto& a, ScheduleProto_SchedulerStatisticsProto& b) { a.Swap(&b); }
  inline void Swap(ScheduleProto_SchedulerStatisticsProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleProto_SchedulerStatisticsProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleProto_SchedulerStatisticsProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleProto_SchedulerStatisticsProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleProto_SchedulerStatisticsProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleProto_SchedulerStatisticsProto& from) { ScheduleProto_SchedulerStatisticsProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleProto_SchedulerStatisticsProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleProto.SchedulerStatisticsProto"; }

 protected:
  explicit ScheduleProto_SchedulerStatisticsProto(::google::protobuf::Arena* arena);
  ScheduleProto_SchedulerStatisticsProto(::google::protobuf::Arena* arena, const ScheduleProto_SchedulerStatisticsProto& from);
  ScheduleProto_SchedulerStatisticsProto(::google::protobuf::Arena* arena, ScheduleProto_SchedulerStatisticsProto&& from) noexcept
      : ScheduleProto_SchedulerStatisticsProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kAllGatherWastedCyclesFieldNumber = 1,
    kAllReduceWastedCyclesFieldNumber = 2,
    kCollectiveBroadcastWastedCyclesFieldNumber = 3,
    kCollectivePermuteWastedCyclesFieldNumber = 4,
    kAllToAllWastedCyclesFieldNumber = 5,
    kRaggedAllToAllWastedCyclesFieldNumber = 6,
    kReduceScatterWastedCyclesFieldNumber = 7,
    kSendWastedCyclesFieldNumber = 8,
    kRecvWastedCyclesFieldNumber = 9,
    kTotalWastedCyclesFieldNumber = 10,
    kTotalCyclesFieldNumber = 11,
    kMemoryPressurePeakFieldNumber = 12,
  };
  // double all_gather_wasted_cycles = 1;
  void clear_all_gather_wasted_cycles() ;
  double all_gather_wasted_cycles() const;
  void set_all_gather_wasted_cycles(double value);

  private:
  double _internal_all_gather_wasted_cycles() const;
  void _internal_set_all_gather_wasted_cycles(double value);

  public:
  // double all_reduce_wasted_cycles = 2;
  void clear_all_reduce_wasted_cycles() ;
  double all_reduce_wasted_cycles() const;
  void set_all_reduce_wasted_cycles(double value);

  private:
  double _internal_all_reduce_wasted_cycles() const;
  void _internal_set_all_reduce_wasted_cycles(double value);

  public:
  // double collective_broadcast_wasted_cycles = 3;
  void clear_collective_broadcast_wasted_cycles() ;
  double collective_broadcast_wasted_cycles() const;
  void set_collective_broadcast_wasted_cycles(double value);

  private:
  double _internal_collective_broadcast_wasted_cycles() const;
  void _internal_set_collective_broadcast_wasted_cycles(double value);

  public:
  // double collective_permute_wasted_cycles = 4;
  void clear_collective_permute_wasted_cycles() ;
  double collective_permute_wasted_cycles() const;
  void set_collective_permute_wasted_cycles(double value);

  private:
  double _internal_collective_permute_wasted_cycles() const;
  void _internal_set_collective_permute_wasted_cycles(double value);

  public:
  // double all_to_all_wasted_cycles = 5;
  void clear_all_to_all_wasted_cycles() ;
  double all_to_all_wasted_cycles() const;
  void set_all_to_all_wasted_cycles(double value);

  private:
  double _internal_all_to_all_wasted_cycles() const;
  void _internal_set_all_to_all_wasted_cycles(double value);

  public:
  // double ragged_all_to_all_wasted_cycles = 6;
  void clear_ragged_all_to_all_wasted_cycles() ;
  double ragged_all_to_all_wasted_cycles() const;
  void set_ragged_all_to_all_wasted_cycles(double value);

  private:
  double _internal_ragged_all_to_all_wasted_cycles() const;
  void _internal_set_ragged_all_to_all_wasted_cycles(double value);

  public:
  // double reduce_scatter_wasted_cycles = 7;
  void clear_reduce_scatter_wasted_cycles() ;
  double reduce_scatter_wasted_cycles() const;
  void set_reduce_scatter_wasted_cycles(double value);

  private:
  double _internal_reduce_scatter_wasted_cycles() const;
  void _internal_set_reduce_scatter_wasted_cycles(double value);

  public:
  // double send_wasted_cycles = 8;
  void clear_send_wasted_cycles() ;
  double send_wasted_cycles() const;
  void set_send_wasted_cycles(double value);

  private:
  double _internal_send_wasted_cycles() const;
  void _internal_set_send_wasted_cycles(double value);

  public:
  // double recv_wasted_cycles = 9;
  void clear_recv_wasted_cycles() ;
  double recv_wasted_cycles() const;
  void set_recv_wasted_cycles(double value);

  private:
  double _internal_recv_wasted_cycles() const;
  void _internal_set_recv_wasted_cycles(double value);

  public:
  // double total_wasted_cycles = 10;
  void clear_total_wasted_cycles() ;
  double total_wasted_cycles() const;
  void set_total_wasted_cycles(double value);

  private:
  double _internal_total_wasted_cycles() const;
  void _internal_set_total_wasted_cycles(double value);

  public:
  // double total_cycles = 11;
  void clear_total_cycles() ;
  double total_cycles() const;
  void set_total_cycles(double value);

  private:
  double _internal_total_cycles() const;
  void _internal_set_total_cycles(double value);

  public:
  // int64 memory_pressure_peak = 12;
  void clear_memory_pressure_peak() ;
  ::int64_t memory_pressure_peak() const;
  void set_memory_pressure_peak(::int64_t value);

  private:
  ::int64_t _internal_memory_pressure_peak() const;
  void _internal_set_memory_pressure_peak(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.ScheduleProto.SchedulerStatisticsProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 12, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleProto_SchedulerStatisticsProto& from_msg);
    double all_gather_wasted_cycles_;
    double all_reduce_wasted_cycles_;
    double collective_broadcast_wasted_cycles_;
    double collective_permute_wasted_cycles_;
    double all_to_all_wasted_cycles_;
    double ragged_all_to_all_wasted_cycles_;
    double reduce_scatter_wasted_cycles_;
    double send_wasted_cycles_;
    double recv_wasted_cycles_;
    double total_wasted_cycles_;
    double total_cycles_;
    ::int64_t memory_pressure_peak_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleProto_Instruction final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleProto.Instruction) */ {
 public:
  inline ScheduleProto_Instruction() : ScheduleProto_Instruction(nullptr) {}
  ~ScheduleProto_Instruction() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleProto_Instruction(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleProto_Instruction(const ScheduleProto_Instruction& from) : ScheduleProto_Instruction(nullptr, from) {}
  inline ScheduleProto_Instruction(ScheduleProto_Instruction&& from) noexcept
      : ScheduleProto_Instruction(nullptr, std::move(from)) {}
  inline ScheduleProto_Instruction& operator=(const ScheduleProto_Instruction& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleProto_Instruction& operator=(ScheduleProto_Instruction&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleProto_Instruction& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleProto_Instruction* internal_default_instance() {
    return reinterpret_cast<const ScheduleProto_Instruction*>(
        &_ScheduleProto_Instruction_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 14;
  friend void swap(ScheduleProto_Instruction& a, ScheduleProto_Instruction& b) { a.Swap(&b); }
  inline void Swap(ScheduleProto_Instruction* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleProto_Instruction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleProto_Instruction* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleProto_Instruction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleProto_Instruction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleProto_Instruction& from) { ScheduleProto_Instruction::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleProto_Instruction* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleProto.Instruction"; }

 protected:
  explicit ScheduleProto_Instruction(::google::protobuf::Arena* arena);
  ScheduleProto_Instruction(::google::protobuf::Arena* arena, const ScheduleProto_Instruction& from);
  ScheduleProto_Instruction(::google::protobuf::Arena* arena, ScheduleProto_Instruction&& from) noexcept
      : ScheduleProto_Instruction(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kIdFieldNumber = 1,
    kStartTimestampCyclesFieldNumber = 2,
    kEndTimestampCyclesFieldNumber = 3,
    kMemoryUsageAfterFieldNumber = 5,
    kPeakMemoryAfterFieldNumber = 6,
  };
  // 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:
  // double start_timestamp_cycles = 2;
  void clear_start_timestamp_cycles() ;
  double start_timestamp_cycles() const;
  void set_start_timestamp_cycles(double value);

  private:
  double _internal_start_timestamp_cycles() const;
  void _internal_set_start_timestamp_cycles(double value);

  public:
  // double end_timestamp_cycles = 3;
  void clear_end_timestamp_cycles() ;
  double end_timestamp_cycles() const;
  void set_end_timestamp_cycles(double value);

  private:
  double _internal_end_timestamp_cycles() const;
  void _internal_set_end_timestamp_cycles(double value);

  public:
  // int64 memory_usage_after = 5;
  void clear_memory_usage_after() ;
  ::int64_t memory_usage_after() const;
  void set_memory_usage_after(::int64_t value);

  private:
  ::int64_t _internal_memory_usage_after() const;
  void _internal_set_memory_usage_after(::int64_t value);

  public:
  // int64 peak_memory_after = 6;
  void clear_peak_memory_after() ;
  ::int64_t peak_memory_after() const;
  void set_peak_memory_after(::int64_t value);

  private:
  ::int64_t _internal_peak_memory_after() const;
  void _internal_set_peak_memory_after(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.ScheduleProto.Instruction)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleProto_Instruction& from_msg);
    ::int64_t id_;
    double start_timestamp_cycles_;
    double end_timestamp_cycles_;
    ::int64_t memory_usage_after_;
    ::int64_t peak_memory_after_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleConfigProto_Instruction final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleConfigProto.Instruction) */ {
 public:
  inline ScheduleConfigProto_Instruction() : ScheduleConfigProto_Instruction(nullptr) {}
  ~ScheduleConfigProto_Instruction() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleConfigProto_Instruction(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleConfigProto_Instruction(const ScheduleConfigProto_Instruction& from) : ScheduleConfigProto_Instruction(nullptr, from) {}
  inline ScheduleConfigProto_Instruction(ScheduleConfigProto_Instruction&& from) noexcept
      : ScheduleConfigProto_Instruction(nullptr, std::move(from)) {}
  inline ScheduleConfigProto_Instruction& operator=(const ScheduleConfigProto_Instruction& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleConfigProto_Instruction& operator=(ScheduleConfigProto_Instruction&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleConfigProto_Instruction& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleConfigProto_Instruction* internal_default_instance() {
    return reinterpret_cast<const ScheduleConfigProto_Instruction*>(
        &_ScheduleConfigProto_Instruction_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 20;
  friend void swap(ScheduleConfigProto_Instruction& a, ScheduleConfigProto_Instruction& b) { a.Swap(&b); }
  inline void Swap(ScheduleConfigProto_Instruction* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleConfigProto_Instruction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleConfigProto_Instruction* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleConfigProto_Instruction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleConfigProto_Instruction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleConfigProto_Instruction& from) { ScheduleConfigProto_Instruction::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleConfigProto_Instruction* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleConfigProto.Instruction"; }

 protected:
  explicit ScheduleConfigProto_Instruction(::google::protobuf::Arena* arena);
  ScheduleConfigProto_Instruction(::google::protobuf::Arena* arena, const ScheduleConfigProto_Instruction& from);
  ScheduleConfigProto_Instruction(::google::protobuf::Arena* arena, ScheduleConfigProto_Instruction&& from) noexcept
      : ScheduleConfigProto_Instruction(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  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.ScheduleConfigProto.Instruction)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      48, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleConfigProto_Instruction& from_msg);
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT HloModuleConfigProto_Int64List final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.Int64List) */ {
 public:
  inline HloModuleConfigProto_Int64List() : HloModuleConfigProto_Int64List(nullptr) {}
  ~HloModuleConfigProto_Int64List() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_Int64List(
      ::google::protobuf::internal::ConstantInitialized);

  inline HloModuleConfigProto_Int64List(const HloModuleConfigProto_Int64List& from) : HloModuleConfigProto_Int64List(nullptr, from) {}
  inline HloModuleConfigProto_Int64List(HloModuleConfigProto_Int64List&& from) noexcept
      : HloModuleConfigProto_Int64List(nullptr, std::move(from)) {}
  inline HloModuleConfigProto_Int64List& operator=(const HloModuleConfigProto_Int64List& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleConfigProto_Int64List& operator=(HloModuleConfigProto_Int64List&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleConfigProto_Int64List& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleConfigProto_Int64List* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto_Int64List*>(
        &_HloModuleConfigProto_Int64List_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(HloModuleConfigProto_Int64List& a, HloModuleConfigProto_Int64List& b) { a.Swap(&b); }
  inline void Swap(HloModuleConfigProto_Int64List* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HloModuleConfigProto_Int64List* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  HloModuleConfigProto_Int64List* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<HloModuleConfigProto_Int64List>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HloModuleConfigProto_Int64List& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const HloModuleConfigProto_Int64List& from) { HloModuleConfigProto_Int64List::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(HloModuleConfigProto_Int64List* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.HloModuleConfigProto.Int64List"; }

 protected:
  explicit HloModuleConfigProto_Int64List(::google::protobuf::Arena* arena);
  HloModuleConfigProto_Int64List(::google::protobuf::Arena* arena, const HloModuleConfigProto_Int64List& from);
  HloModuleConfigProto_Int64List(::google::protobuf::Arena* arena, HloModuleConfigProto_Int64List&& from) noexcept
      : HloModuleConfigProto_Int64List(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated int64 vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;

  public:
  void clear_vals() ;
  ::int64_t vals(int index) const;
  void set_vals(int index, ::int64_t value);
  void add_vals(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& vals() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_vals();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_vals() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_vals();

  public:
  // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.Int64List)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const HloModuleConfigProto_Int64List& from_msg);
    ::google::protobuf::RepeatedField<::int64_t> vals_;
    mutable ::google::protobuf::internal::CachedSize _vals_cached_byte_size_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT HloModuleConfigProto_BoolList final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.BoolList) */ {
 public:
  inline HloModuleConfigProto_BoolList() : HloModuleConfigProto_BoolList(nullptr) {}
  ~HloModuleConfigProto_BoolList() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_BoolList(
      ::google::protobuf::internal::ConstantInitialized);

  inline HloModuleConfigProto_BoolList(const HloModuleConfigProto_BoolList& from) : HloModuleConfigProto_BoolList(nullptr, from) {}
  inline HloModuleConfigProto_BoolList(HloModuleConfigProto_BoolList&& from) noexcept
      : HloModuleConfigProto_BoolList(nullptr, std::move(from)) {}
  inline HloModuleConfigProto_BoolList& operator=(const HloModuleConfigProto_BoolList& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleConfigProto_BoolList& operator=(HloModuleConfigProto_BoolList&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleConfigProto_BoolList& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleConfigProto_BoolList* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto_BoolList*>(
        &_HloModuleConfigProto_BoolList_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(HloModuleConfigProto_BoolList& a, HloModuleConfigProto_BoolList& b) { a.Swap(&b); }
  inline void Swap(HloModuleConfigProto_BoolList* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HloModuleConfigProto_BoolList* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  HloModuleConfigProto_BoolList* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<HloModuleConfigProto_BoolList>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HloModuleConfigProto_BoolList& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const HloModuleConfigProto_BoolList& from) { HloModuleConfigProto_BoolList::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(HloModuleConfigProto_BoolList* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.HloModuleConfigProto.BoolList"; }

 protected:
  explicit HloModuleConfigProto_BoolList(::google::protobuf::Arena* arena);
  HloModuleConfigProto_BoolList(::google::protobuf::Arena* arena, const HloModuleConfigProto_BoolList& from);
  HloModuleConfigProto_BoolList(::google::protobuf::Arena* arena, HloModuleConfigProto_BoolList&& from) noexcept
      : HloModuleConfigProto_BoolList(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated bool vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;

  public:
  void clear_vals() ;
  bool vals(int index) const;
  void set_vals(int index, bool value);
  void add_vals(bool value);
  const ::google::protobuf::RepeatedField<bool>& vals() const;
  ::google::protobuf::RepeatedField<bool>* mutable_vals();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_vals() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_vals();

  public:
  // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.BoolList)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const HloModuleConfigProto_BoolList& from_msg);
    ::google::protobuf::RepeatedField<bool> vals_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse, std::string, ::int64_t,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_INT64> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse, std::string, ::int64_t,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT64>;
  HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse*>(
        &_HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      62, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT GpuCompilationEnvironment final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.GpuCompilationEnvironment) */ {
 public:
  inline GpuCompilationEnvironment() : GpuCompilationEnvironment(nullptr) {}
  ~GpuCompilationEnvironment() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GpuCompilationEnvironment(
      ::google::protobuf::internal::ConstantInitialized);

  inline GpuCompilationEnvironment(const GpuCompilationEnvironment& from) : GpuCompilationEnvironment(nullptr, from) {}
  inline GpuCompilationEnvironment(GpuCompilationEnvironment&& from) noexcept
      : GpuCompilationEnvironment(nullptr, std::move(from)) {}
  inline GpuCompilationEnvironment& operator=(const GpuCompilationEnvironment& from) {
    CopyFrom(from);
    return *this;
  }
  inline GpuCompilationEnvironment& operator=(GpuCompilationEnvironment&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GpuCompilationEnvironment& default_instance() {
    return *internal_default_instance();
  }
  static inline const GpuCompilationEnvironment* internal_default_instance() {
    return reinterpret_cast<const GpuCompilationEnvironment*>(
        &_GpuCompilationEnvironment_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(GpuCompilationEnvironment& a, GpuCompilationEnvironment& b) { a.Swap(&b); }
  inline void Swap(GpuCompilationEnvironment* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GpuCompilationEnvironment* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  GpuCompilationEnvironment* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<GpuCompilationEnvironment>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GpuCompilationEnvironment& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const GpuCompilationEnvironment& from) { GpuCompilationEnvironment::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GpuCompilationEnvironment* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.GpuCompilationEnvironment"; }

 protected:
  explicit GpuCompilationEnvironment(::google::protobuf::Arena* arena);
  GpuCompilationEnvironment(::google::protobuf::Arena* arena, const GpuCompilationEnvironment& from);
  GpuCompilationEnvironment(::google::protobuf::Arena* arena, GpuCompilationEnvironment&& from) noexcept
      : GpuCompilationEnvironment(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDummyFlagFieldNumber = 1,
  };
  // int64 dummy_flag = 1;
  void clear_dummy_flag() ;
  ::int64_t dummy_flag() const;
  void set_dummy_flag(::int64_t value);

  private:
  ::int64_t _internal_dummy_flag() const;
  void _internal_set_dummy_flag(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.GpuCompilationEnvironment)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const GpuCompilationEnvironment& from_msg);
    ::int64_t dummy_flag_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse, std::string, std::string,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse, std::string, std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>;
  DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse*>(
        &_DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      78, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse, std::string, std::string,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse, std::string, std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>;
  DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse*>(
        &_DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      61, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleProto_ComputationScheduleProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleProto.ComputationScheduleProto) */ {
 public:
  inline ScheduleProto_ComputationScheduleProto() : ScheduleProto_ComputationScheduleProto(nullptr) {}
  ~ScheduleProto_ComputationScheduleProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleProto_ComputationScheduleProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleProto_ComputationScheduleProto(const ScheduleProto_ComputationScheduleProto& from) : ScheduleProto_ComputationScheduleProto(nullptr, from) {}
  inline ScheduleProto_ComputationScheduleProto(ScheduleProto_ComputationScheduleProto&& from) noexcept
      : ScheduleProto_ComputationScheduleProto(nullptr, std::move(from)) {}
  inline ScheduleProto_ComputationScheduleProto& operator=(const ScheduleProto_ComputationScheduleProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleProto_ComputationScheduleProto& operator=(ScheduleProto_ComputationScheduleProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleProto_ComputationScheduleProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleProto_ComputationScheduleProto* internal_default_instance() {
    return reinterpret_cast<const ScheduleProto_ComputationScheduleProto*>(
        &_ScheduleProto_ComputationScheduleProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 16;
  friend void swap(ScheduleProto_ComputationScheduleProto& a, ScheduleProto_ComputationScheduleProto& b) { a.Swap(&b); }
  inline void Swap(ScheduleProto_ComputationScheduleProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleProto_ComputationScheduleProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleProto_ComputationScheduleProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleProto_ComputationScheduleProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleProto_ComputationScheduleProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleProto_ComputationScheduleProto& from) { ScheduleProto_ComputationScheduleProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleProto_ComputationScheduleProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleProto.ComputationScheduleProto"; }

 protected:
  explicit ScheduleProto_ComputationScheduleProto(::google::protobuf::Arena* arena);
  ScheduleProto_ComputationScheduleProto(::google::protobuf::Arena* arena, const ScheduleProto_ComputationScheduleProto& from);
  ScheduleProto_ComputationScheduleProto(::google::protobuf::Arena* arena, ScheduleProto_ComputationScheduleProto&& from) noexcept
      : ScheduleProto_ComputationScheduleProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInstructionsFieldNumber = 2,
    kSchedulerStatisticsFieldNumber = 3,
    kComputationIdFieldNumber = 1,
    kCyclesPerMicrosecondFieldNumber = 4,
  };
  // repeated .xla.ScheduleProto.Instruction instructions = 2;
  int instructions_size() const;
  private:
  int _internal_instructions_size() const;

  public:
  void clear_instructions() ;
  ::xla::ScheduleProto_Instruction* mutable_instructions(int index);
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>* mutable_instructions();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>& _internal_instructions() const;
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>* _internal_mutable_instructions();
  public:
  const ::xla::ScheduleProto_Instruction& instructions(int index) const;
  ::xla::ScheduleProto_Instruction* add_instructions();
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>& instructions() const;
  // .xla.ScheduleProto.SchedulerStatisticsProto scheduler_statistics = 3;
  bool has_scheduler_statistics() const;
  void clear_scheduler_statistics() ;
  const ::xla::ScheduleProto_SchedulerStatisticsProto& scheduler_statistics() const;
  PROTOBUF_NODISCARD ::xla::ScheduleProto_SchedulerStatisticsProto* release_scheduler_statistics();
  ::xla::ScheduleProto_SchedulerStatisticsProto* mutable_scheduler_statistics();
  void set_allocated_scheduler_statistics(::xla::ScheduleProto_SchedulerStatisticsProto* value);
  void unsafe_arena_set_allocated_scheduler_statistics(::xla::ScheduleProto_SchedulerStatisticsProto* value);
  ::xla::ScheduleProto_SchedulerStatisticsProto* unsafe_arena_release_scheduler_statistics();

  private:
  const ::xla::ScheduleProto_SchedulerStatisticsProto& _internal_scheduler_statistics() const;
  ::xla::ScheduleProto_SchedulerStatisticsProto* _internal_mutable_scheduler_statistics();

  public:
  // int64 computation_id = 1;
  void clear_computation_id() ;
  ::int64_t computation_id() const;
  void set_computation_id(::int64_t value);

  private:
  ::int64_t _internal_computation_id() const;
  void _internal_set_computation_id(::int64_t value);

  public:
  // int64 cycles_per_microsecond = 4;
  void clear_cycles_per_microsecond() ;
  ::int64_t cycles_per_microsecond() const;
  void set_cycles_per_microsecond(::int64_t value);

  private:
  ::int64_t _internal_cycles_per_microsecond() const;
  void _internal_set_cycles_per_microsecond(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.ScheduleProto.ComputationScheduleProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleProto_ComputationScheduleProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::ScheduleProto_Instruction > instructions_;
    ::xla::ScheduleProto_SchedulerStatisticsProto* scheduler_statistics_;
    ::int64_t computation_id_;
    ::int64_t cycles_per_microsecond_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleConfigProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleConfigProto) */ {
 public:
  inline ScheduleConfigProto() : ScheduleConfigProto(nullptr) {}
  ~ScheduleConfigProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleConfigProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleConfigProto(const ScheduleConfigProto& from) : ScheduleConfigProto(nullptr, from) {}
  inline ScheduleConfigProto(ScheduleConfigProto&& from) noexcept
      : ScheduleConfigProto(nullptr, std::move(from)) {}
  inline ScheduleConfigProto& operator=(const ScheduleConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleConfigProto& operator=(ScheduleConfigProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleConfigProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleConfigProto* internal_default_instance() {
    return reinterpret_cast<const ScheduleConfigProto*>(
        &_ScheduleConfigProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 21;
  friend void swap(ScheduleConfigProto& a, ScheduleConfigProto& b) { a.Swap(&b); }
  inline void Swap(ScheduleConfigProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleConfigProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleConfigProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleConfigProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleConfigProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleConfigProto& from) { ScheduleConfigProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleConfigProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleConfigProto"; }

 protected:
  explicit ScheduleConfigProto(::google::protobuf::Arena* arena);
  ScheduleConfigProto(::google::protobuf::Arena* arena, const ScheduleConfigProto& from);
  ScheduleConfigProto(::google::protobuf::Arena* arena, ScheduleConfigProto&& from) noexcept
      : ScheduleConfigProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Instruction = ScheduleConfigProto_Instruction;

  // accessors -------------------------------------------------------
  enum : int {
    kSequenceFieldNumber = 1,
  };
  // repeated .xla.ScheduleConfigProto.Instruction sequence = 1;
  int sequence_size() const;
  private:
  int _internal_sequence_size() const;

  public:
  void clear_sequence() ;
  ::xla::ScheduleConfigProto_Instruction* mutable_sequence(int index);
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>* mutable_sequence();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>& _internal_sequence() const;
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>* _internal_mutable_sequence();
  public:
  const ::xla::ScheduleConfigProto_Instruction& sequence(int index) const;
  ::xla::ScheduleConfigProto_Instruction* add_sequence();
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>& sequence() const;
  // @@protoc_insertion_point(class_scope:xla.ScheduleConfigProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleConfigProto& from_msg);
    ::google::protobuf::RepeatedPtrField< ::xla::ScheduleConfigProto_Instruction > sequence_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT HloModuleConfigProto_Int64ListList final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.Int64ListList) */ {
 public:
  inline HloModuleConfigProto_Int64ListList() : HloModuleConfigProto_Int64ListList(nullptr) {}
  ~HloModuleConfigProto_Int64ListList() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_Int64ListList(
      ::google::protobuf::internal::ConstantInitialized);

  inline HloModuleConfigProto_Int64ListList(const HloModuleConfigProto_Int64ListList& from) : HloModuleConfigProto_Int64ListList(nullptr, from) {}
  inline HloModuleConfigProto_Int64ListList(HloModuleConfigProto_Int64ListList&& from) noexcept
      : HloModuleConfigProto_Int64ListList(nullptr, std::move(from)) {}
  inline HloModuleConfigProto_Int64ListList& operator=(const HloModuleConfigProto_Int64ListList& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleConfigProto_Int64ListList& operator=(HloModuleConfigProto_Int64ListList&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleConfigProto_Int64ListList& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleConfigProto_Int64ListList* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto_Int64ListList*>(
        &_HloModuleConfigProto_Int64ListList_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(HloModuleConfigProto_Int64ListList& a, HloModuleConfigProto_Int64ListList& b) { a.Swap(&b); }
  inline void Swap(HloModuleConfigProto_Int64ListList* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HloModuleConfigProto_Int64ListList* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  HloModuleConfigProto_Int64ListList* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<HloModuleConfigProto_Int64ListList>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HloModuleConfigProto_Int64ListList& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const HloModuleConfigProto_Int64ListList& from) { HloModuleConfigProto_Int64ListList::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(HloModuleConfigProto_Int64ListList* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.HloModuleConfigProto.Int64ListList"; }

 protected:
  explicit HloModuleConfigProto_Int64ListList(::google::protobuf::Arena* arena);
  HloModuleConfigProto_Int64ListList(::google::protobuf::Arena* arena, const HloModuleConfigProto_Int64ListList& from);
  HloModuleConfigProto_Int64ListList(::google::protobuf::Arena* arena, HloModuleConfigProto_Int64ListList&& from) noexcept
      : HloModuleConfigProto_Int64ListList(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kListsFieldNumber = 1,
  };
  // repeated .xla.HloModuleConfigProto.Int64List lists = 1;
  int lists_size() const;
  private:
  int _internal_lists_size() const;

  public:
  void clear_lists() ;
  ::xla::HloModuleConfigProto_Int64List* mutable_lists(int index);
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>* mutable_lists();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>& _internal_lists() const;
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>* _internal_mutable_lists();
  public:
  const ::xla::HloModuleConfigProto_Int64List& lists(int index) const;
  ::xla::HloModuleConfigProto_Int64List* add_lists();
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>& lists() const;
  // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.Int64ListList)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const HloModuleConfigProto_Int64ListList& from_msg);
    ::google::protobuf::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List > lists_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class HloModuleConfigProto_DotConfigEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          HloModuleConfigProto_DotConfigEntry_DoNotUse, std::string, ::xla::HloModuleConfigProto_Int64List,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      HloModuleConfigProto_DotConfigEntry_DoNotUse, std::string, ::xla::HloModuleConfigProto_Int64List,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>;
  HloModuleConfigProto_DotConfigEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_DotConfigEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit HloModuleConfigProto_DotConfigEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const HloModuleConfigProto_DotConfigEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto_DotConfigEntry_DoNotUse*>(
        &_HloModuleConfigProto_DotConfigEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      51, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT DebugOptions final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.DebugOptions) */ {
 public:
  inline DebugOptions() : DebugOptions(nullptr) {}
  ~DebugOptions() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DebugOptions(
      ::google::protobuf::internal::ConstantInitialized);

  inline DebugOptions(const DebugOptions& from) : DebugOptions(nullptr, from) {}
  inline DebugOptions(DebugOptions&& from) noexcept
      : DebugOptions(nullptr, std::move(from)) {}
  inline DebugOptions& operator=(const DebugOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline DebugOptions& operator=(DebugOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DebugOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const DebugOptions* internal_default_instance() {
    return reinterpret_cast<const DebugOptions*>(
        &_DebugOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(DebugOptions& a, DebugOptions& b) { a.Swap(&b); }
  inline void Swap(DebugOptions* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DebugOptions* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  DebugOptions* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<DebugOptions>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DebugOptions& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const DebugOptions& from) { DebugOptions::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DebugOptions* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.DebugOptions"; }

 protected:
  explicit DebugOptions(::google::protobuf::Arena* arena);
  DebugOptions(::google::protobuf::Arena* arena, const DebugOptions& from);
  DebugOptions(::google::protobuf::Arena* arena, DebugOptions&& from) noexcept
      : DebugOptions(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using CollectiveOpType = DebugOptions_CollectiveOpType;
  static constexpr CollectiveOpType NOOP = DebugOptions_CollectiveOpType_NOOP;
  static constexpr CollectiveOpType ALLREDUCE = DebugOptions_CollectiveOpType_ALLREDUCE;
  static constexpr CollectiveOpType ALLGATHER = DebugOptions_CollectiveOpType_ALLGATHER;
  static constexpr CollectiveOpType REDUCESCATTER = DebugOptions_CollectiveOpType_REDUCESCATTER;
  static constexpr CollectiveOpType COLLECTIVEBROADCAST = DebugOptions_CollectiveOpType_COLLECTIVEBROADCAST;
  static constexpr CollectiveOpType ALLTOALL = DebugOptions_CollectiveOpType_ALLTOALL;
  static constexpr CollectiveOpType COLLECTIVEPERMUTE = DebugOptions_CollectiveOpType_COLLECTIVEPERMUTE;
  static constexpr CollectiveOpType RAGGEDALLTOALL = DebugOptions_CollectiveOpType_RAGGEDALLTOALL;
  static constexpr CollectiveOpType ALLCOLLECTIVES = DebugOptions_CollectiveOpType_ALLCOLLECTIVES;
  static inline bool CollectiveOpType_IsValid(int value) {
    return DebugOptions_CollectiveOpType_IsValid(value);
  }
  static constexpr CollectiveOpType CollectiveOpType_MIN = DebugOptions_CollectiveOpType_CollectiveOpType_MIN;
  static constexpr CollectiveOpType CollectiveOpType_MAX = DebugOptions_CollectiveOpType_CollectiveOpType_MAX;
  static constexpr int CollectiveOpType_ARRAYSIZE = DebugOptions_CollectiveOpType_CollectiveOpType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* CollectiveOpType_descriptor() {
    return DebugOptions_CollectiveOpType_descriptor();
  }
  template <typename T>
  static inline const std::string& CollectiveOpType_Name(T value) {
    return DebugOptions_CollectiveOpType_Name(value);
  }
  static inline bool CollectiveOpType_Parse(absl::string_view name, CollectiveOpType* value) {
    return DebugOptions_CollectiveOpType_Parse(name, value);
  }
  using CommandBufferCmdType = DebugOptions_CommandBufferCmdType;
  static constexpr CommandBufferCmdType INVALID = DebugOptions_CommandBufferCmdType_INVALID;
  static constexpr CommandBufferCmdType FUSION = DebugOptions_CommandBufferCmdType_FUSION;
  static constexpr CommandBufferCmdType CUBLAS = DebugOptions_CommandBufferCmdType_CUBLAS;
  static constexpr CommandBufferCmdType CUDNN = DebugOptions_CommandBufferCmdType_CUDNN;
  static constexpr CommandBufferCmdType COLLECTIVES = DebugOptions_CommandBufferCmdType_COLLECTIVES;
  static constexpr CommandBufferCmdType CONDITIONAL = DebugOptions_CommandBufferCmdType_CONDITIONAL;
  static constexpr CommandBufferCmdType WHILE = DebugOptions_CommandBufferCmdType_WHILE;
  static constexpr CommandBufferCmdType CUSTOM_CALL = DebugOptions_CommandBufferCmdType_CUSTOM_CALL;
  static constexpr CommandBufferCmdType CUBLASLT = DebugOptions_CommandBufferCmdType_CUBLASLT;
  static constexpr CommandBufferCmdType DYNAMIC_SLICE_FUSION = DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_FUSION;
  static constexpr CommandBufferCmdType DYNAMIC_SLICE_COPY_FUSION = DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_COPY_FUSION;
  static inline bool CommandBufferCmdType_IsValid(int value) {
    return DebugOptions_CommandBufferCmdType_IsValid(value);
  }
  static constexpr CommandBufferCmdType CommandBufferCmdType_MIN = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MIN;
  static constexpr CommandBufferCmdType CommandBufferCmdType_MAX = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MAX;
  static constexpr int CommandBufferCmdType_ARRAYSIZE = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* CommandBufferCmdType_descriptor() {
    return DebugOptions_CommandBufferCmdType_descriptor();
  }
  template <typename T>
  static inline const std::string& CommandBufferCmdType_Name(T value) {
    return DebugOptions_CommandBufferCmdType_Name(value);
  }
  static inline bool CommandBufferCmdType_Parse(absl::string_view name, CommandBufferCmdType* value) {
    return DebugOptions_CommandBufferCmdType_Parse(name, value);
  }
  using LibNvJitLinkMode = DebugOptions_LibNvJitLinkMode;
  static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_AUTO = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_AUTO;
  static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_DISABLED = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_DISABLED;
  static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_ENABLED = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_ENABLED;
  static inline bool LibNvJitLinkMode_IsValid(int value) {
    return DebugOptions_LibNvJitLinkMode_IsValid(value);
  }
  static constexpr LibNvJitLinkMode LibNvJitLinkMode_MIN = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MIN;
  static constexpr LibNvJitLinkMode LibNvJitLinkMode_MAX = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MAX;
  static constexpr int LibNvJitLinkMode_ARRAYSIZE = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* LibNvJitLinkMode_descriptor() {
    return DebugOptions_LibNvJitLinkMode_descriptor();
  }
  template <typename T>
  static inline const std::string& LibNvJitLinkMode_Name(T value) {
    return DebugOptions_LibNvJitLinkMode_Name(value);
  }
  static inline bool LibNvJitLinkMode_Parse(absl::string_view name, LibNvJitLinkMode* value) {
    return DebugOptions_LibNvJitLinkMode_Parse(name, value);
  }
  using PGLEStrictnessLevel = DebugOptions_PGLEStrictnessLevel;
  static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_OFF = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_OFF;
  static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_WARN = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_WARN;
  static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_ERROR = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_ERROR;
  static inline bool PGLEStrictnessLevel_IsValid(int value) {
    return DebugOptions_PGLEStrictnessLevel_IsValid(value);
  }
  static constexpr PGLEStrictnessLevel PGLEStrictnessLevel_MIN = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MIN;
  static constexpr PGLEStrictnessLevel PGLEStrictnessLevel_MAX = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MAX;
  static constexpr int PGLEStrictnessLevel_ARRAYSIZE = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PGLEStrictnessLevel_descriptor() {
    return DebugOptions_PGLEStrictnessLevel_descriptor();
  }
  template <typename T>
  static inline const std::string& PGLEStrictnessLevel_Name(T value) {
    return DebugOptions_PGLEStrictnessLevel_Name(value);
  }
  static inline bool PGLEStrictnessLevel_Parse(absl::string_view name, PGLEStrictnessLevel* value) {
    return DebugOptions_PGLEStrictnessLevel_Parse(name, value);
  }
  using ShapeChecks = DebugOptions_ShapeChecks;
  static constexpr ShapeChecks IGNORE = DebugOptions_ShapeChecks_IGNORE;
  static constexpr ShapeChecks RUNTIME = DebugOptions_ShapeChecks_RUNTIME;
  static constexpr ShapeChecks COMPILE_TIME = DebugOptions_ShapeChecks_COMPILE_TIME;
  static inline bool ShapeChecks_IsValid(int value) {
    return DebugOptions_ShapeChecks_IsValid(value);
  }
  static constexpr ShapeChecks ShapeChecks_MIN = DebugOptions_ShapeChecks_ShapeChecks_MIN;
  static constexpr ShapeChecks ShapeChecks_MAX = DebugOptions_ShapeChecks_ShapeChecks_MAX;
  static constexpr int ShapeChecks_ARRAYSIZE = DebugOptions_ShapeChecks_ShapeChecks_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* ShapeChecks_descriptor() {
    return DebugOptions_ShapeChecks_descriptor();
  }
  template <typename T>
  static inline const std::string& ShapeChecks_Name(T value) {
    return DebugOptions_ShapeChecks_Name(value);
  }
  static inline bool ShapeChecks_Parse(absl::string_view name, ShapeChecks* value) {
    return DebugOptions_ShapeChecks_Parse(name, value);
  }
  using WhileLoopUnrolling = DebugOptions_WhileLoopUnrolling;
  static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_NO_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_NO_UNROLL;
  static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_DOUBLE_BUFFER = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_DOUBLE_BUFFER;
  static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_FULL_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_FULL_UNROLL;
  static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_AUTO_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_AUTO_UNROLL;
  static inline bool WhileLoopUnrolling_IsValid(int value) {
    return DebugOptions_WhileLoopUnrolling_IsValid(value);
  }
  static constexpr WhileLoopUnrolling WhileLoopUnrolling_MIN = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MIN;
  static constexpr WhileLoopUnrolling WhileLoopUnrolling_MAX = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MAX;
  static constexpr int WhileLoopUnrolling_ARRAYSIZE = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* WhileLoopUnrolling_descriptor() {
    return DebugOptions_WhileLoopUnrolling_descriptor();
  }
  template <typename T>
  static inline const std::string& WhileLoopUnrolling_Name(T value) {
    return DebugOptions_WhileLoopUnrolling_Name(value);
  }
  static inline bool WhileLoopUnrolling_Parse(absl::string_view name, WhileLoopUnrolling* value) {
    return DebugOptions_WhileLoopUnrolling_Parse(name, value);
  }
  using XnnGraphFusionMode = DebugOptions_XnnGraphFusionMode;
  static constexpr XnnGraphFusionMode XNN_GRAPH_FUSION_MODE_DISABLED = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_DISABLED;
  static constexpr XnnGraphFusionMode XNN_GRAPH_FUSION_MODE_GREEDY = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY;
  static constexpr XnnGraphFusionMode XNN_GRAPH_FUSION_MODE_GREEDY_SLINKY = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY_SLINKY;
  static inline bool XnnGraphFusionMode_IsValid(int value) {
    return DebugOptions_XnnGraphFusionMode_IsValid(value);
  }
  static constexpr XnnGraphFusionMode XnnGraphFusionMode_MIN = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MIN;
  static constexpr XnnGraphFusionMode XnnGraphFusionMode_MAX = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MAX;
  static constexpr int XnnGraphFusionMode_ARRAYSIZE = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* XnnGraphFusionMode_descriptor() {
    return DebugOptions_XnnGraphFusionMode_descriptor();
  }
  template <typename T>
  static inline const std::string& XnnGraphFusionMode_Name(T value) {
    return DebugOptions_XnnGraphFusionMode_Name(value);
  }
  static inline bool XnnGraphFusionMode_Parse(absl::string_view name, XnnGraphFusionMode* value) {
    return DebugOptions_XnnGraphFusionMode_Parse(name, value);
  }
  using GenericTritonEmitterFeature = DebugOptions_GenericTritonEmitterFeature;
  static constexpr GenericTritonEmitterFeature GENERIC_TRITON_EMITTER_UNSPECIFIED = DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_UNSPECIFIED;
  static constexpr GenericTritonEmitterFeature GENERIC_TRITON_EMITTER_ENABLE_NESTED_GEMM = DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ENABLE_NESTED_GEMM;
  static constexpr GenericTritonEmitterFeature GENERIC_TRITON_EMITTER_DISABLE_LEGACY_GEMM = DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_DISABLE_LEGACY_GEMM;
  static constexpr GenericTritonEmitterFeature GENERIC_TRITON_EMITTER_ALLOW_ALL_OPS_IN_GEMM_FUSION = DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ALLOW_ALL_OPS_IN_GEMM_FUSION;
  static constexpr GenericTritonEmitterFeature GENERIC_TRITON_EMITTER_ALLOW_ALL_GEMM_SHAPES = DebugOptions_GenericTritonEmitterFeature_GENERIC_TRITON_EMITTER_ALLOW_ALL_GEMM_SHAPES;
  static inline bool GenericTritonEmitterFeature_IsValid(int value) {
    return DebugOptions_GenericTritonEmitterFeature_IsValid(value);
  }
  static constexpr GenericTritonEmitterFeature GenericTritonEmitterFeature_MIN = DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_MIN;
  static constexpr GenericTritonEmitterFeature GenericTritonEmitterFeature_MAX = DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_MAX;
  static constexpr int GenericTritonEmitterFeature_ARRAYSIZE = DebugOptions_GenericTritonEmitterFeature_GenericTritonEmitterFeature_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* GenericTritonEmitterFeature_descriptor() {
    return DebugOptions_GenericTritonEmitterFeature_descriptor();
  }
  template <typename T>
  static inline const std::string& GenericTritonEmitterFeature_Name(T value) {
    return DebugOptions_GenericTritonEmitterFeature_Name(value);
  }
  static inline bool GenericTritonEmitterFeature_Parse(absl::string_view name, GenericTritonEmitterFeature* value) {
    return DebugOptions_GenericTritonEmitterFeature_Parse(name, value);
  }
  using PipelineParallelismOptLevel = DebugOptions_PipelineParallelismOptLevel;
  static constexpr PipelineParallelismOptLevel PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE;
  static constexpr PipelineParallelismOptLevel PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE;
  static inline bool PipelineParallelismOptLevel_IsValid(int value) {
    return DebugOptions_PipelineParallelismOptLevel_IsValid(value);
  }
  static constexpr PipelineParallelismOptLevel PipelineParallelismOptLevel_MIN = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MIN;
  static constexpr PipelineParallelismOptLevel PipelineParallelismOptLevel_MAX = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MAX;
  static constexpr int PipelineParallelismOptLevel_ARRAYSIZE = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PipelineParallelismOptLevel_descriptor() {
    return DebugOptions_PipelineParallelismOptLevel_descriptor();
  }
  template <typename T>
  static inline const std::string& PipelineParallelismOptLevel_Name(T value) {
    return DebugOptions_PipelineParallelismOptLevel_Name(value);
  }
  static inline bool PipelineParallelismOptLevel_Parse(absl::string_view name, PipelineParallelismOptLevel* value) {
    return DebugOptions_PipelineParallelismOptLevel_Parse(name, value);
  }
  using StepMarkerLocation = DebugOptions_StepMarkerLocation;
  static constexpr StepMarkerLocation STEP_MARK_AT_ENTRY = DebugOptions_StepMarkerLocation_STEP_MARK_AT_ENTRY;
  static constexpr StepMarkerLocation STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP = DebugOptions_StepMarkerLocation_STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP;
  static constexpr StepMarkerLocation STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP = DebugOptions_StepMarkerLocation_STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP;
  static constexpr StepMarkerLocation STEP_MARK_NONE = DebugOptions_StepMarkerLocation_STEP_MARK_NONE;
  static inline bool StepMarkerLocation_IsValid(int value) {
    return DebugOptions_StepMarkerLocation_IsValid(value);
  }
  static constexpr StepMarkerLocation StepMarkerLocation_MIN = DebugOptions_StepMarkerLocation_StepMarkerLocation_MIN;
  static constexpr StepMarkerLocation StepMarkerLocation_MAX = DebugOptions_StepMarkerLocation_StepMarkerLocation_MAX;
  static constexpr int StepMarkerLocation_ARRAYSIZE = DebugOptions_StepMarkerLocation_StepMarkerLocation_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* StepMarkerLocation_descriptor() {
    return DebugOptions_StepMarkerLocation_descriptor();
  }
  template <typename T>
  static inline const std::string& StepMarkerLocation_Name(T value) {
    return DebugOptions_StepMarkerLocation_Name(value);
  }
  static inline bool StepMarkerLocation_Parse(absl::string_view name, StepMarkerLocation* value) {
    return DebugOptions_StepMarkerLocation_Parse(name, value);
  }
  using PartitioningAlgorithm = DebugOptions_PartitioningAlgorithm;
  static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_NOOP = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_NOOP;
  static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP0 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP0;
  static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP1 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP1;
  static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP2 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP2;
  static inline bool PartitioningAlgorithm_IsValid(int value) {
    return DebugOptions_PartitioningAlgorithm_IsValid(value);
  }
  static constexpr PartitioningAlgorithm PartitioningAlgorithm_MIN = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MIN;
  static constexpr PartitioningAlgorithm PartitioningAlgorithm_MAX = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MAX;
  static constexpr int PartitioningAlgorithm_ARRAYSIZE = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PartitioningAlgorithm_descriptor() {
    return DebugOptions_PartitioningAlgorithm_descriptor();
  }
  template <typename T>
  static inline const std::string& PartitioningAlgorithm_Name(T value) {
    return DebugOptions_PartitioningAlgorithm_Name(value);
  }
  static inline bool PartitioningAlgorithm_Parse(absl::string_view name, PartitioningAlgorithm* value) {
    return DebugOptions_PartitioningAlgorithm_Parse(name, value);
  }
  using AutotuneCacheMode = DebugOptions_AutotuneCacheMode;
  static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_UNSPECIFIED = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UNSPECIFIED;
  static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_UPDATE = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UPDATE;
  static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_READ = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_READ;
  static inline bool AutotuneCacheMode_IsValid(int value) {
    return DebugOptions_AutotuneCacheMode_IsValid(value);
  }
  static constexpr AutotuneCacheMode AutotuneCacheMode_MIN = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MIN;
  static constexpr AutotuneCacheMode AutotuneCacheMode_MAX = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MAX;
  static constexpr int AutotuneCacheMode_ARRAYSIZE = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* AutotuneCacheMode_descriptor() {
    return DebugOptions_AutotuneCacheMode_descriptor();
  }
  template <typename T>
  static inline const std::string& AutotuneCacheMode_Name(T value) {
    return DebugOptions_AutotuneCacheMode_Name(value);
  }
  static inline bool AutotuneCacheMode_Parse(absl::string_view name, AutotuneCacheMode* value) {
    return DebugOptions_AutotuneCacheMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kXlaDisableHloPassesFieldNumber = 30,
    kXlaEnableHloPassesOnlyFieldNumber = 124,
    kXlaGpuPtxFileFieldNumber = 127,
    kXlaGpuLlvmIrFileFieldNumber = 150,
    kXlaGpuEnableCommandBufferFieldNumber = 258,
    kXlaGpuDisableAsyncCollectivesFieldNumber = 289,
    kLegacyCommandBufferCustomCallTargetsFieldNumber = 314,
    kXlaGpuAnalyticalLatencyEstimatorOptionsFieldNumber = 357,
    kXlaGpuUnsupportedGenericTritonEmitterFeaturesFieldNumber = 398,
    kXlaBackendExtraOptionsFieldNumber = 500,
    kXlaGpuCudaDataDirFieldNumber = 61,
    kXlaDumpToFieldNumber = 109,
    kXlaDumpHloModuleReFieldNumber = 110,
    kXlaDumpHloPassReFieldNumber = 111,
    kXlaGpuAlgorithmDenylistPathFieldNumber = 128,
    kXlaDumpHloPipelineReFieldNumber = 154,
    kXlaGpuPgleProfileFileOrDirectoryPathFieldNumber = 210,
    kXlaGpuDumpAutotuneResultsToFieldNumber = 222,
    kXlaGpuLoadAutotuneResultsFromFieldNumber = 223,
    kXlaGpuTargetConfigFilenameFieldNumber = 261,
    kXlaGpuEnableCustomFusionsReFieldNumber = 264,
    kXlaGpuDumpAutotuneLogsToFieldNumber = 292,
    kXlaGpuOverrideGemmAutotunerFieldNumber = 295,
    kXlaGpuKernelCacheFileFieldNumber = 306,
    kXlaGpuPerFusionAutotuneCacheDirFieldNumber = 310,
    kXlaCpuMaxIsaFieldNumber = 333,
    kXlaGpuExperimentalCollectivePerfTablePathFieldNumber = 377,
    kXlaGpuExperimentalMatmulPerfTablePathFieldNumber = 383,
    kXlaBackendOptimizationLevelFieldNumber = 31,
    kXlaDisableAllHloPassesFieldNumber = 104,
    kXlaEmbedIrInExecutableFieldNumber = 33,
    kXlaEliminateHloImplicitBroadcastFieldNumber = 35,
    kXlaCpuMultiThreadEigenFieldNumber = 60,
    kXlaLlvmEnableAliasScopeMetadataFieldNumber = 70,
    kXlaLlvmEnableNoaliasMetadataFieldNumber = 71,
    kXlaLlvmEnableInvariantLoadMetadataFieldNumber = 72,
    kXlaLlvmDisableExpensivePassesFieldNumber = 73,
    kXlaTestAllOutputLayoutsFieldNumber = 90,
    kXlaTestAllInputLayoutsFieldNumber = 91,
    kXlaHloGraphShardingColorFieldNumber = 92,
    kXlaCpuUseOnednnFieldNumber = 97,
    kXlaForceHostPlatformDeviceCountFieldNumber = 102,
    kXlaStepMarkerLocationFieldNumber = 108,
    kXlaDumpHloAsTextFieldNumber = 112,
    kXlaDumpHloAsProtoFieldNumber = 113,
    kXlaDumpHloAsDotFieldNumber = 114,
    kXlaDumpHloAsUrlFieldNumber = 115,
    kXlaGpuUseRuntimeFusionFieldNumber = 181,
    kXlaGpuVerifyTritonFusionNumericsFieldNumber = 291,
    kXlaHloGraphAddressesFieldNumber = 2,
    kXlaHloProfileFieldNumber = 9,
    kXlaGpuAutotuneLevelFieldNumber = 123,
    kXlaCpuFastMathHonorDivisionFieldNumber = 126,
    kXlaCpuFastMathHonorFunctionsFieldNumber = 129,
    kXlaCpuFastMathHonorInfsFieldNumber = 121,
    kXlaCpuFastMathHonorNansFieldNumber = 120,
    kXlaDumpHloAsHtmlFieldNumber = 116,
    kXlaDumpFusionVisualizationFieldNumber = 149,
    kXlaDumpHloSnapshotsFieldNumber = 118,
    kXlaDumpIncludeTimestampFieldNumber = 131,
    kXlaDumpMaxHloModulesFieldNumber = 132,
    kXlaMultiheapSizeConstraintPerHeapFieldNumber = 142,
    kXlaGpuForceConvNchwFieldNumber = 125,
    kXlaGpuForceConvNhwcFieldNumber = 146,
    kXlaGpuFtzFieldNumber = 62,
    kXlaGpuFusedAttentionUseCudnnRngFieldNumber = 235,
    kXlaGpuForceCompilationParallelismFieldNumber = 147,
    kXlaGpuAllReduceBlueconnectNumDevicesPerHostFieldNumber = 159,
    kXlaGpuAllReduceCombineThresholdBytesFieldNumber = 157,
    kXlaDumpModuleMetadataFieldNumber = 144,
    kXlaDumpCompressProtosFieldNumber = 151,
    kXlaDumpHloAsLongTextFieldNumber = 164,
    kXlaDumpEnableMlirPrettyFormFieldNumber = 185,
    kXlaGpuShapeChecksFieldNumber = 170,
    kXlaGpuNcclTerminationTimeoutSecondsFieldNumber = 163,
    kXlaGpuRedzoneScratchMaxMegabytesFieldNumber = 167,
    kXlaGpuEnableCustomFusionsFieldNumber = 263,
    kXlaGpuEnableDynamicSliceFusionFieldNumber = 105,
    kXlaGpuEnableFastMinMaxFieldNumber = 100,
    kXlaGpuEnableHighestPriorityAsyncStreamFieldNumber = 216,
    kXlaAllowExcessPrecisionFieldNumber = 122,
    kXlaHloEvaluatorUseFastPathFieldNumber = 106,
    kXlaAllowScalarIndexDynamicOpsFieldNumber = 107,
    kXlaFlagsResetFieldNumber = 364,
    kXlaGpuCopyInsertionUseRegionAnalysisFieldNumber = 236,
    kXlaGpuCrashOnVerificationFailuresFieldNumber = 101,
    kXlaGpuCublasFallbackFieldNumber = 247,
    kXlaGpuDeterministicOpsFieldNumber = 148,
    kXlaPartitioningAlgorithmFieldNumber = 187,
    kXlaDumpFullHloConfigFieldNumber = 381,
    kXlaTpuDetectNanFieldNumber = 135,
    kXlaTpuDetectInfFieldNumber = 136,
    kXlaCpuEnableXprofTracemeFieldNumber = 137,
    kXlaGpuCollectiveInflationFactorFieldNumber = 205,
    kXlaCpuUseAclFieldNumber = 174,
    kXlaCpuStrictDotConvMathFieldNumber = 175,
    kXlaDumpLatencyHidingScheduleFieldNumber = 182,
    kXlaDumpLargeConstantsFieldNumber = 290,
    kXlaGpuGraphMinGraphSizeFieldNumber = 208,
    kXlaGpuAllGatherCombineThresholdBytesFieldNumber = 212,
    kXlaGpuDisableGpuasmOptimizationsFieldNumber = 103,
    kXlaGpuDumpAutotunedGemmFusionsFieldNumber = 232,
    kXlaGpuDumpHloUnoptimizedSnapshotsFieldNumber = 352,
    kXlaGpuDumpLlvmirFieldNumber = 155,
    kXlaGpuEnableSharedConstantsFieldNumber = 165,
    kXlaGpuEnableSplitKAutotuningFieldNumber = 241,
    kXlaGpuEnableTritonGemmFieldNumber = 188,
    kXlaGpuEnableTritonHopperFieldNumber = 266,
    kXlaGpuReduceScatterCombineThresholdBytesFieldNumber = 213,
    kXlaGpuEnableCubRadixSortFieldNumber = 259,
    kXlaGpuEnableCublasltFieldNumber = 166,
    kXlaGpuEnableCudnnInt8X32ConvolutionReorderingFieldNumber = 189,
    kXlaGpuEnableCudnnLayerNormFieldNumber = 262,
    kXlaCpuCopyInsertionUseRegionAnalysisFieldNumber = 337,
    kXlaCpuEnableConcurrencyOptimizedSchedulerFieldNumber = 307,
    kXlaCpuEnableFastMathFieldNumber = 99,
    kXlaCpuEnableFastMinMaxFieldNumber = 140,
    kXlaGpuAutoSpmdPartitioningMemoryBudgetGbFieldNumber = 224,
    kXlaGpuAutoSpmdPartitioningMemoryBudgetRatioFieldNumber = 225,
    kXlaGpuRedzonePaddingBytesFieldNumber = 228,
    kXlaGpuEnablePipelinedAllReduceFieldNumber = 217,
    kXlaGpuEnablePipelinedCollectivesFieldNumber = 239,
    kXlaGpuEnablePipelinedP2PFieldNumber = 246,
    kXlaGpuEnablePipelinedReduceScatterFieldNumber = 231,
    kXlaDetailedLoggingFieldNumber = 252,
    kXlaEnableDumpingFieldNumber = 253,
    kXlaLlvmForceInlineBeforeSplitFieldNumber = 300,
    kXlaDumpDisableMetadataFieldNumber = 153,
    kXlaGpuCollectivePermuteDecomposerThresholdFieldNumber = 237,
    kXlaGpuEnableWhileLoopDoubleBufferingFieldNumber = 248,
    kXlaGpuEnableWhileLoopReduceScatterCodeMotionFieldNumber = 203,
    kXlaGpuExcludeNondeterministicOpsFieldNumber = 297,
    kXlaGpuExhaustiveTilingSearchFieldNumber = 219,
    kXlaGpuTempBufferUseSeparateColorFieldNumber = 312,
    kXlaGpuTritonGemmAnyFieldNumber = 190,
    kXlaGpuUnsafeFallbackToDriverOnPtxasNotFoundFieldNumber = 138,
    kXlaGpuUnsupportedAnnotateWithEmitterLocFieldNumber = 358,
    kXlaDebugBufferAssignmentShowMaxFieldNumber = 251,
    kXlaGpuEnableNcclCliqueOptimizationFieldNumber = 244,
    kXlaGpuEnableNcclCommSplittingFieldNumber = 272,
    kXlaGpuEnableNcclUserBuffersFieldNumber = 267,
    kXlaGpuEnablePipelinedAllGatherFieldNumber = 227,
    kXlaGpuEnableHostMemoryOffloadingFieldNumber = 296,
    kXlaGpuEnableLatencyHidingSchedulerFieldNumber = 186,
    kXlaGpuEnableLibnvptxcompilerFieldNumber = 269,
    kXlaGpuEnableLlvmModuleCompilationParallelismFieldNumber = 268,
    kXlaGpuLlvmVerificationLevelFieldNumber = 256,
    kXlaGpuMemoryLimitSlopFactorFieldNumber = 260,
    kXlaGpuThresholdForWindowedEinsumMibFieldNumber = 265,
    kXlaGpuEnableReassociationForConvertedArFieldNumber = 209,
    kXlaGpuEnableReduceScatterCombineByDimFieldNumber = 257,
    kXlaGpuEnableReductionEpilogueFusionFieldNumber = 243,
    kXlaGpuEnableScatterDeterminismExpanderFieldNumber = 345,
    kXlaGpuRequireCompleteAotAutotuneResultsFieldNumber = 284,
    kXlaGpuRequireExclusiveLockFieldNumber = 347,
    kXlaGpuShardAutotuningFieldNumber = 304,
    kXlaGpuStrictConvAlgorithmPickerFieldNumber = 156,
    kXlaGpuNcclCollectiveMaxNchannelsFieldNumber = 273,
    kXlaGpuNcclP2PMaxNchannelsFieldNumber = 274,
    kXlaGpuNcclInitMaxRankPerRootRatioFieldNumber = 277,
    kXlaGpuGemmRewriteSizeThresholdFieldNumber = 283,
    kXlaGpuAutotuneMaxSolutionsFieldNumber = 288,
    kXlaGpuCudnnGemmFusionLevelFieldNumber = 285,
    kXlaGpuGenerateDebugInfoFieldNumber = 348,
    kXlaGpuGenerateLineInfoFieldNumber = 349,
    kXlaGpuGraphEnableConcurrentRegionFieldNumber = 215,
    kXlaGpuMockCustomCallsFieldNumber = 245,
    kXlaGpuEnableAllGatherCombineByDimFieldNumber = 254,
    kXlaGpuEnableAnalyticalLatencyEstimatorFieldNumber = 255,
    kXlaGpuEnableAnalyticalSolLatencyEstimatorFieldNumber = 356,
    kXlaGpuEnableApproxCostlyCollectivesFieldNumber = 305,
    kXlaGpuEnableWhileLoopUnrollingFieldNumber = 294,
    kXlaReduceWindowRewriteBaseLengthFieldNumber = 293,
    kXlaCmdBufferTraceCacheSizeFieldNumber = 311,
    kXlaCpuPreferVectorWidthFieldNumber = 308,
    kXlaEnableFastMathFieldNumber = 335,
    kXlaGpuAsyncDotFieldNumber = 321,
    kXlaGpuCollectCostModelStatsFieldNumber = 240,
    kXlaGpuCollectivesUsePersistentCliquesFieldNumber = 354,
    kXlaGpuAutotuneGemmRtolFieldNumber = 316,
    kXlaGpuCudnnGemmMaxPlansFieldNumber = 318,
    kXlaCpuParallelCodegenSplitCountFieldNumber = 323,
    kXlaGpuExperimentalAutotuneCacheModeFieldNumber = 324,
    kXlaSyntaxSugarAsyncOpsFieldNumber = 315,
    kXlaEnableCommandBuffersDuringProfilingFieldNumber = 317,
    kXlaIgnoreChannelIdFieldNumber = 330,
    kXlaPjrtAllowAutoLayoutInHloFieldNumber = 344,
    kXlaGpuExecutableWarnStuckTimeoutSecondsFieldNumber = 327,
    kXlaGpuExecutableTerminateTimeoutSecondsFieldNumber = 328,
    kXlaGpuDotMergerThresholdMbFieldNumber = 331,
    kXlaGpuExperimentalStreamAnnotationFieldNumber = 342,
    kXlaGpuExperimentalUseAutotunerPassFieldNumber = 396,
    kXlaGpuFailPtxCompilationOnRegisterSpillingFieldNumber = 353,
    kXlaGpuFilterKernelsSpillingRegistersOnAutotuningFieldNumber = 250,
    kXlaGpuExperimentalParallelCollectiveOverlapLimitFieldNumber = 336,
    kXlaGpuOperandBytesThresholdForWindowedEinsumFieldNumber = 339,
    kXlaGpuPgleAccuracyCheckerFieldNumber = 341,
    kXlaGpuMultiStreamedWindowedEinsumFieldNumber = 280,
    kXlaGpuNcclAsyncExecutionFieldNumber = 393,
    kXlaGpuNcclBlockingCommunicatorsFieldNumber = 390,
    kXlaGpuNcclTerminateOnErrorFieldNumber = 301,
    kXlaGpuLibnvjitlinkModeFieldNumber = 343,
    kXlaGpuExperimentalPipelineParallelismOptLevelFieldNumber = 351,
    kXlaCpuGenerateUniqueCStyleKernelEntryPointsFieldNumber = 372,
    kXlaCpuUseFusionEmittersFieldNumber = 376,
    kXlaCpuUseThunkRuntimeFieldNumber = 298,
    kXlaCpuUseXnnpackFieldNumber = 359,
    kXlaGpuExperimentalDisableBinaryLibrariesFieldNumber = 329,
    kXlaGpuExperimentalDumpFdoProfilesFieldNumber = 338,
    kXlaGpuExperimentalEnableAlltoallWindowedEinsumFieldNumber = 360,
    kXlaGpuExperimentalEnableCommandBufferOnThunksFieldNumber = 394,
    kXlaGpuExperimentalEnableSubchannelDequantisationFusionFieldNumber = 368,
    kXlaGpuExperimentalEnableTritonHerolessPriorityFusionFieldNumber = 340,
    kXlaGpuExperimentalEnableTritonTmaFieldNumber = 355,
    kXlaGpuExperimentalPackDotOperandsAlongKDimensionFieldNumber = 362,
    kXlaGpuUnsupportedEnableAllReduceDecomposerFieldNumber = 384,
    kXlaGpuUnsupportedEnableRaggedAllToAllDecomposerFieldNumber = 350,
    kXlaGpuUnsupportedEnableTritonGemmFieldNumber = 322,
    kXlaGpuUnsupportedEnableTritonMultiOutputFusionFieldNumber = 382,
    kXlaGpuUnsupportedUseAllReduceOneShotKernelFieldNumber = 387,
    kXlaGpuUnsupportedUseRaggedAllToAllOneShotKernelFieldNumber = 375,
    kXlaGpuUseInprocessLldFieldNumber = 389,
    kXlaGpuUseMemcpyLocalP2PFieldNumber = 287,
    kXlaCpuExperimentalXnnGraphFusionModeFieldNumber = 365,
    kXlaGpuExperimentalEnableFusionBlockLevelRewriterFieldNumber = 334,
    kXlaGpuExperimentalEnableHeuristicCollectiveCombiningFieldNumber = 366,
    kXlaGpuExperimentalEnableNvshmemFieldNumber = 388,
    kXlaGpuExperimentalEnableSplitKRewriteFieldNumber = 386,
    kXlaHloPassFixDetectCyclesFieldNumber = 370,
    kXlaUnsupportedCrashOnHloPassFixMaxIterationsFieldNumber = 363,
    kXlaUnsupportedCrashOnHloPassNoopChangeFieldNumber = 379,
    kXlaUnsupportedCrashOnHloPassSilentHloChangeFieldNumber = 380,
    kXlaGpuExperimentalCollectiveCseDistanceThresholdFieldNumber = 374,
    kXlaGpuCollectivePermuteCombineThresholdBytesFieldNumber = 378,
    kXlaTestAddCommandBufferModeFieldNumber = 373,
    kXlaEarlyExitWithLayoutsFieldNumber = 397,
    kXlaGpuFirstCollectiveCallWarnStuckTimeoutSecondsFieldNumber = 391,
    kXlaGpuFirstCollectiveCallTerminateTimeoutSecondsFieldNumber = 392,
    kXlaCpuEmitterVerificationLevelFieldNumber = 395,
  };
  // repeated string xla_disable_hlo_passes = 30;
  int xla_disable_hlo_passes_size() const;
  private:
  int _internal_xla_disable_hlo_passes_size() const;

  public:
  void clear_xla_disable_hlo_passes() ;
  const std::string& xla_disable_hlo_passes(int index) const;
  std::string* mutable_xla_disable_hlo_passes(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_disable_hlo_passes(int index, Arg_&& value, Args_... args);
  std::string* add_xla_disable_hlo_passes();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_xla_disable_hlo_passes(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& xla_disable_hlo_passes() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_xla_disable_hlo_passes();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_xla_disable_hlo_passes() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_xla_disable_hlo_passes();

  public:
  // repeated string xla_enable_hlo_passes_only = 124;
  int xla_enable_hlo_passes_only_size() const;
  private:
  int _internal_xla_enable_hlo_passes_only_size() const;

  public:
  void clear_xla_enable_hlo_passes_only() ;
  const std::string& xla_enable_hlo_passes_only(int index) const;
  std::string* mutable_xla_enable_hlo_passes_only(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_enable_hlo_passes_only(int index, Arg_&& value, Args_... args);
  std::string* add_xla_enable_hlo_passes_only();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_xla_enable_hlo_passes_only(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& xla_enable_hlo_passes_only() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_xla_enable_hlo_passes_only();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_xla_enable_hlo_passes_only() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_xla_enable_hlo_passes_only();

  public:
  // repeated string xla_gpu_ptx_file = 127;
  int xla_gpu_ptx_file_size() const;
  private:
  int _internal_xla_gpu_ptx_file_size() const;

  public:
  void clear_xla_gpu_ptx_file() ;
  const std::string& xla_gpu_ptx_file(int index) const;
  std::string* mutable_xla_gpu_ptx_file(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_ptx_file(int index, Arg_&& value, Args_... args);
  std::string* add_xla_gpu_ptx_file();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_xla_gpu_ptx_file(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& xla_gpu_ptx_file() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_xla_gpu_ptx_file();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_xla_gpu_ptx_file() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_xla_gpu_ptx_file();

  public:
  // repeated string xla_gpu_llvm_ir_file = 150;
  int xla_gpu_llvm_ir_file_size() const;
  private:
  int _internal_xla_gpu_llvm_ir_file_size() const;

  public:
  void clear_xla_gpu_llvm_ir_file() ;
  const std::string& xla_gpu_llvm_ir_file(int index) const;
  std::string* mutable_xla_gpu_llvm_ir_file(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_llvm_ir_file(int index, Arg_&& value, Args_... args);
  std::string* add_xla_gpu_llvm_ir_file();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_xla_gpu_llvm_ir_file(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& xla_gpu_llvm_ir_file() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_xla_gpu_llvm_ir_file();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_xla_gpu_llvm_ir_file() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_xla_gpu_llvm_ir_file();

  public:
  // repeated .xla.DebugOptions.CommandBufferCmdType xla_gpu_enable_command_buffer = 258;
  int xla_gpu_enable_command_buffer_size() const;
  private:
  int _internal_xla_gpu_enable_command_buffer_size() const;

  public:
  void clear_xla_gpu_enable_command_buffer() ;
  public:
  ::xla::DebugOptions_CommandBufferCmdType xla_gpu_enable_command_buffer(int index) const;
  void set_xla_gpu_enable_command_buffer(int index, ::xla::DebugOptions_CommandBufferCmdType value);
  void add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value);
  const ::google::protobuf::RepeatedField<int>& xla_gpu_enable_command_buffer() const;
  ::google::protobuf::RepeatedField<int>* mutable_xla_gpu_enable_command_buffer();

  private:
  const ::google::protobuf::RepeatedField<int>& _internal_xla_gpu_enable_command_buffer() const;
  ::google::protobuf::RepeatedField<int>* _internal_mutable_xla_gpu_enable_command_buffer();

  public:
  // repeated .xla.DebugOptions.CollectiveOpType xla_gpu_disable_async_collectives = 289;
  int xla_gpu_disable_async_collectives_size() const;
  private:
  int _internal_xla_gpu_disable_async_collectives_size() const;

  public:
  void clear_xla_gpu_disable_async_collectives() ;
  public:
  ::xla::DebugOptions_CollectiveOpType xla_gpu_disable_async_collectives(int index) const;
  void set_xla_gpu_disable_async_collectives(int index, ::xla::DebugOptions_CollectiveOpType value);
  void add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value);
  const ::google::protobuf::RepeatedField<int>& xla_gpu_disable_async_collectives() const;
  ::google::protobuf::RepeatedField<int>* mutable_xla_gpu_disable_async_collectives();

  private:
  const ::google::protobuf::RepeatedField<int>& _internal_xla_gpu_disable_async_collectives() const;
  ::google::protobuf::RepeatedField<int>* _internal_mutable_xla_gpu_disable_async_collectives();

  public:
  // repeated string legacy_command_buffer_custom_call_targets = 314;
  int legacy_command_buffer_custom_call_targets_size() const;
  private:
  int _internal_legacy_command_buffer_custom_call_targets_size() const;

  public:
  void clear_legacy_command_buffer_custom_call_targets() ;
  const std::string& legacy_command_buffer_custom_call_targets(int index) const;
  std::string* mutable_legacy_command_buffer_custom_call_targets(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_legacy_command_buffer_custom_call_targets(int index, Arg_&& value, Args_... args);
  std::string* add_legacy_command_buffer_custom_call_targets();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_legacy_command_buffer_custom_call_targets(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& legacy_command_buffer_custom_call_targets() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_legacy_command_buffer_custom_call_targets();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_legacy_command_buffer_custom_call_targets() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_legacy_command_buffer_custom_call_targets();

  public:
  // map<string, string> xla_gpu_analytical_latency_estimator_options = 357;
  int xla_gpu_analytical_latency_estimator_options_size() const;
  private:
  int _internal_xla_gpu_analytical_latency_estimator_options_size() const;

  public:
  void clear_xla_gpu_analytical_latency_estimator_options() ;
  const ::google::protobuf::Map<std::string, std::string>& xla_gpu_analytical_latency_estimator_options() const;
  ::google::protobuf::Map<std::string, std::string>* mutable_xla_gpu_analytical_latency_estimator_options();

  private:
  const ::google::protobuf::Map<std::string, std::string>& _internal_xla_gpu_analytical_latency_estimator_options() const;
  ::google::protobuf::Map<std::string, std::string>* _internal_mutable_xla_gpu_analytical_latency_estimator_options();

  public:
  // repeated .xla.DebugOptions.GenericTritonEmitterFeature xla_gpu_unsupported_generic_triton_emitter_features = 398;
  int xla_gpu_unsupported_generic_triton_emitter_features_size() const;
  private:
  int _internal_xla_gpu_unsupported_generic_triton_emitter_features_size() const;

  public:
  void clear_xla_gpu_unsupported_generic_triton_emitter_features() ;
  public:
  ::xla::DebugOptions_GenericTritonEmitterFeature xla_gpu_unsupported_generic_triton_emitter_features(int index) const;
  void set_xla_gpu_unsupported_generic_triton_emitter_features(int index, ::xla::DebugOptions_GenericTritonEmitterFeature value);
  void add_xla_gpu_unsupported_generic_triton_emitter_features(::xla::DebugOptions_GenericTritonEmitterFeature value);
  const ::google::protobuf::RepeatedField<int>& xla_gpu_unsupported_generic_triton_emitter_features() const;
  ::google::protobuf::RepeatedField<int>* mutable_xla_gpu_unsupported_generic_triton_emitter_features();

  private:
  const ::google::protobuf::RepeatedField<int>& _internal_xla_gpu_unsupported_generic_triton_emitter_features() const;
  ::google::protobuf::RepeatedField<int>* _internal_mutable_xla_gpu_unsupported_generic_triton_emitter_features();

  public:
  // map<string, string> xla_backend_extra_options = 500;
  int xla_backend_extra_options_size() const;
  private:
  int _internal_xla_backend_extra_options_size() const;

  public:
  void clear_xla_backend_extra_options() ;
  const ::google::protobuf::Map<std::string, std::string>& xla_backend_extra_options() const;
  ::google::protobuf::Map<std::string, std::string>* mutable_xla_backend_extra_options();

  private:
  const ::google::protobuf::Map<std::string, std::string>& _internal_xla_backend_extra_options() const;
  ::google::protobuf::Map<std::string, std::string>* _internal_mutable_xla_backend_extra_options();

  public:
  // optional string xla_gpu_cuda_data_dir = 61;
  bool has_xla_gpu_cuda_data_dir() const;
  void clear_xla_gpu_cuda_data_dir() ;
  const std::string& xla_gpu_cuda_data_dir() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_cuda_data_dir(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_cuda_data_dir();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_cuda_data_dir();
  void set_allocated_xla_gpu_cuda_data_dir(std::string* value);

  private:
  const std::string& _internal_xla_gpu_cuda_data_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_cuda_data_dir(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_cuda_data_dir();

  public:
  // optional string xla_dump_to = 109;
  bool has_xla_dump_to() const;
  void clear_xla_dump_to() ;
  const std::string& xla_dump_to() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_dump_to(Arg_&& arg, Args_... args);
  std::string* mutable_xla_dump_to();
  PROTOBUF_NODISCARD std::string* release_xla_dump_to();
  void set_allocated_xla_dump_to(std::string* value);

  private:
  const std::string& _internal_xla_dump_to() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_to(
      const std::string& value);
  std::string* _internal_mutable_xla_dump_to();

  public:
  // optional string xla_dump_hlo_module_re = 110;
  bool has_xla_dump_hlo_module_re() const;
  void clear_xla_dump_hlo_module_re() ;
  const std::string& xla_dump_hlo_module_re() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_dump_hlo_module_re(Arg_&& arg, Args_... args);
  std::string* mutable_xla_dump_hlo_module_re();
  PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_module_re();
  void set_allocated_xla_dump_hlo_module_re(std::string* value);

  private:
  const std::string& _internal_xla_dump_hlo_module_re() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_module_re(
      const std::string& value);
  std::string* _internal_mutable_xla_dump_hlo_module_re();

  public:
  // optional string xla_dump_hlo_pass_re = 111;
  bool has_xla_dump_hlo_pass_re() const;
  void clear_xla_dump_hlo_pass_re() ;
  const std::string& xla_dump_hlo_pass_re() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_dump_hlo_pass_re(Arg_&& arg, Args_... args);
  std::string* mutable_xla_dump_hlo_pass_re();
  PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_pass_re();
  void set_allocated_xla_dump_hlo_pass_re(std::string* value);

  private:
  const std::string& _internal_xla_dump_hlo_pass_re() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_pass_re(
      const std::string& value);
  std::string* _internal_mutable_xla_dump_hlo_pass_re();

  public:
  // optional string xla_gpu_algorithm_denylist_path = 128;
  bool has_xla_gpu_algorithm_denylist_path() const;
  void clear_xla_gpu_algorithm_denylist_path() ;
  const std::string& xla_gpu_algorithm_denylist_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_algorithm_denylist_path(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_algorithm_denylist_path();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_algorithm_denylist_path();
  void set_allocated_xla_gpu_algorithm_denylist_path(std::string* value);

  private:
  const std::string& _internal_xla_gpu_algorithm_denylist_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_algorithm_denylist_path(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_algorithm_denylist_path();

  public:
  // optional string xla_dump_hlo_pipeline_re = 154;
  bool has_xla_dump_hlo_pipeline_re() const;
  void clear_xla_dump_hlo_pipeline_re() ;
  const std::string& xla_dump_hlo_pipeline_re() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_dump_hlo_pipeline_re(Arg_&& arg, Args_... args);
  std::string* mutable_xla_dump_hlo_pipeline_re();
  PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_pipeline_re();
  void set_allocated_xla_dump_hlo_pipeline_re(std::string* value);

  private:
  const std::string& _internal_xla_dump_hlo_pipeline_re() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_pipeline_re(
      const std::string& value);
  std::string* _internal_mutable_xla_dump_hlo_pipeline_re();

  public:
  // optional string xla_gpu_pgle_profile_file_or_directory_path = 210;
  bool has_xla_gpu_pgle_profile_file_or_directory_path() const;
  void clear_xla_gpu_pgle_profile_file_or_directory_path() ;
  const std::string& xla_gpu_pgle_profile_file_or_directory_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_pgle_profile_file_or_directory_path(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_pgle_profile_file_or_directory_path();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_pgle_profile_file_or_directory_path();
  void set_allocated_xla_gpu_pgle_profile_file_or_directory_path(std::string* value);

  private:
  const std::string& _internal_xla_gpu_pgle_profile_file_or_directory_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_pgle_profile_file_or_directory_path(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_pgle_profile_file_or_directory_path();

  public:
  // optional string xla_gpu_dump_autotune_results_to = 222;
  bool has_xla_gpu_dump_autotune_results_to() const;
  void clear_xla_gpu_dump_autotune_results_to() ;
  const std::string& xla_gpu_dump_autotune_results_to() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_dump_autotune_results_to(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_dump_autotune_results_to();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_dump_autotune_results_to();
  void set_allocated_xla_gpu_dump_autotune_results_to(std::string* value);

  private:
  const std::string& _internal_xla_gpu_dump_autotune_results_to() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_dump_autotune_results_to(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_dump_autotune_results_to();

  public:
  // optional string xla_gpu_load_autotune_results_from = 223;
  bool has_xla_gpu_load_autotune_results_from() const;
  void clear_xla_gpu_load_autotune_results_from() ;
  const std::string& xla_gpu_load_autotune_results_from() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_load_autotune_results_from(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_load_autotune_results_from();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_load_autotune_results_from();
  void set_allocated_xla_gpu_load_autotune_results_from(std::string* value);

  private:
  const std::string& _internal_xla_gpu_load_autotune_results_from() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_load_autotune_results_from(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_load_autotune_results_from();

  public:
  // optional string xla_gpu_target_config_filename = 261;
  bool has_xla_gpu_target_config_filename() const;
  void clear_xla_gpu_target_config_filename() ;
  const std::string& xla_gpu_target_config_filename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_target_config_filename(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_target_config_filename();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_target_config_filename();
  void set_allocated_xla_gpu_target_config_filename(std::string* value);

  private:
  const std::string& _internal_xla_gpu_target_config_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_target_config_filename(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_target_config_filename();

  public:
  // optional string xla_gpu_enable_custom_fusions_re = 264;
  bool has_xla_gpu_enable_custom_fusions_re() const;
  void clear_xla_gpu_enable_custom_fusions_re() ;
  const std::string& xla_gpu_enable_custom_fusions_re() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_enable_custom_fusions_re(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_enable_custom_fusions_re();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_enable_custom_fusions_re();
  void set_allocated_xla_gpu_enable_custom_fusions_re(std::string* value);

  private:
  const std::string& _internal_xla_gpu_enable_custom_fusions_re() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_enable_custom_fusions_re(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_enable_custom_fusions_re();

  public:
  // optional string xla_gpu_dump_autotune_logs_to = 292;
  bool has_xla_gpu_dump_autotune_logs_to() const;
  void clear_xla_gpu_dump_autotune_logs_to() ;
  const std::string& xla_gpu_dump_autotune_logs_to() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_dump_autotune_logs_to(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_dump_autotune_logs_to();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_dump_autotune_logs_to();
  void set_allocated_xla_gpu_dump_autotune_logs_to(std::string* value);

  private:
  const std::string& _internal_xla_gpu_dump_autotune_logs_to() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_dump_autotune_logs_to(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_dump_autotune_logs_to();

  public:
  // optional string xla_gpu_override_gemm_autotuner = 295;
  bool has_xla_gpu_override_gemm_autotuner() const;
  void clear_xla_gpu_override_gemm_autotuner() ;
  const std::string& xla_gpu_override_gemm_autotuner() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_override_gemm_autotuner(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_override_gemm_autotuner();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_override_gemm_autotuner();
  void set_allocated_xla_gpu_override_gemm_autotuner(std::string* value);

  private:
  const std::string& _internal_xla_gpu_override_gemm_autotuner() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_override_gemm_autotuner(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_override_gemm_autotuner();

  public:
  // optional string xla_gpu_kernel_cache_file = 306;
  bool has_xla_gpu_kernel_cache_file() const;
  void clear_xla_gpu_kernel_cache_file() ;
  const std::string& xla_gpu_kernel_cache_file() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_kernel_cache_file(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_kernel_cache_file();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_kernel_cache_file();
  void set_allocated_xla_gpu_kernel_cache_file(std::string* value);

  private:
  const std::string& _internal_xla_gpu_kernel_cache_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_kernel_cache_file(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_kernel_cache_file();

  public:
  // optional string xla_gpu_per_fusion_autotune_cache_dir = 310;
  bool has_xla_gpu_per_fusion_autotune_cache_dir() const;
  void clear_xla_gpu_per_fusion_autotune_cache_dir() ;
  const std::string& xla_gpu_per_fusion_autotune_cache_dir() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_per_fusion_autotune_cache_dir(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_per_fusion_autotune_cache_dir();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_per_fusion_autotune_cache_dir();
  void set_allocated_xla_gpu_per_fusion_autotune_cache_dir(std::string* value);

  private:
  const std::string& _internal_xla_gpu_per_fusion_autotune_cache_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_per_fusion_autotune_cache_dir(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_per_fusion_autotune_cache_dir();

  public:
  // optional string xla_cpu_max_isa = 333;
  bool has_xla_cpu_max_isa() const;
  void clear_xla_cpu_max_isa() ;
  const std::string& xla_cpu_max_isa() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_cpu_max_isa(Arg_&& arg, Args_... args);
  std::string* mutable_xla_cpu_max_isa();
  PROTOBUF_NODISCARD std::string* release_xla_cpu_max_isa();
  void set_allocated_xla_cpu_max_isa(std::string* value);

  private:
  const std::string& _internal_xla_cpu_max_isa() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_cpu_max_isa(
      const std::string& value);
  std::string* _internal_mutable_xla_cpu_max_isa();

  public:
  // optional string xla_gpu_experimental_collective_perf_table_path = 377;
  bool has_xla_gpu_experimental_collective_perf_table_path() const;
  void clear_xla_gpu_experimental_collective_perf_table_path() ;
  const std::string& xla_gpu_experimental_collective_perf_table_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_experimental_collective_perf_table_path(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_experimental_collective_perf_table_path();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_experimental_collective_perf_table_path();
  void set_allocated_xla_gpu_experimental_collective_perf_table_path(std::string* value);

  private:
  const std::string& _internal_xla_gpu_experimental_collective_perf_table_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_experimental_collective_perf_table_path(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_experimental_collective_perf_table_path();

  public:
  // optional string xla_gpu_experimental_matmul_perf_table_path = 383;
  bool has_xla_gpu_experimental_matmul_perf_table_path() const;
  void clear_xla_gpu_experimental_matmul_perf_table_path() ;
  const std::string& xla_gpu_experimental_matmul_perf_table_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_xla_gpu_experimental_matmul_perf_table_path(Arg_&& arg, Args_... args);
  std::string* mutable_xla_gpu_experimental_matmul_perf_table_path();
  PROTOBUF_NODISCARD std::string* release_xla_gpu_experimental_matmul_perf_table_path();
  void set_allocated_xla_gpu_experimental_matmul_perf_table_path(std::string* value);

  private:
  const std::string& _internal_xla_gpu_experimental_matmul_perf_table_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_experimental_matmul_perf_table_path(
      const std::string& value);
  std::string* _internal_mutable_xla_gpu_experimental_matmul_perf_table_path();

  public:
  // optional int32 xla_backend_optimization_level = 31;
  bool has_xla_backend_optimization_level() const;
  void clear_xla_backend_optimization_level() ;
  ::int32_t xla_backend_optimization_level() const;
  void set_xla_backend_optimization_level(::int32_t value);

  private:
  ::int32_t _internal_xla_backend_optimization_level() const;
  void _internal_set_xla_backend_optimization_level(::int32_t value);

  public:
  // optional bool xla_disable_all_hlo_passes = 104;
  bool has_xla_disable_all_hlo_passes() const;
  void clear_xla_disable_all_hlo_passes() ;
  bool xla_disable_all_hlo_passes() const;
  void set_xla_disable_all_hlo_passes(bool value);

  private:
  bool _internal_xla_disable_all_hlo_passes() const;
  void _internal_set_xla_disable_all_hlo_passes(bool value);

  public:
  // optional bool xla_embed_ir_in_executable = 33;
  bool has_xla_embed_ir_in_executable() const;
  void clear_xla_embed_ir_in_executable() ;
  bool xla_embed_ir_in_executable() const;
  void set_xla_embed_ir_in_executable(bool value);

  private:
  bool _internal_xla_embed_ir_in_executable() const;
  void _internal_set_xla_embed_ir_in_executable(bool value);

  public:
  // optional bool xla_eliminate_hlo_implicit_broadcast = 35;
  bool has_xla_eliminate_hlo_implicit_broadcast() const;
  void clear_xla_eliminate_hlo_implicit_broadcast() ;
  bool xla_eliminate_hlo_implicit_broadcast() const;
  void set_xla_eliminate_hlo_implicit_broadcast(bool value);

  private:
  bool _internal_xla_eliminate_hlo_implicit_broadcast() const;
  void _internal_set_xla_eliminate_hlo_implicit_broadcast(bool value);

  public:
  // optional bool xla_cpu_multi_thread_eigen = 60;
  bool has_xla_cpu_multi_thread_eigen() const;
  void clear_xla_cpu_multi_thread_eigen() ;
  bool xla_cpu_multi_thread_eigen() const;
  void set_xla_cpu_multi_thread_eigen(bool value);

  private:
  bool _internal_xla_cpu_multi_thread_eigen() const;
  void _internal_set_xla_cpu_multi_thread_eigen(bool value);

  public:
  // optional bool xla_llvm_enable_alias_scope_metadata = 70;
  bool has_xla_llvm_enable_alias_scope_metadata() const;
  void clear_xla_llvm_enable_alias_scope_metadata() ;
  bool xla_llvm_enable_alias_scope_metadata() const;
  void set_xla_llvm_enable_alias_scope_metadata(bool value);

  private:
  bool _internal_xla_llvm_enable_alias_scope_metadata() const;
  void _internal_set_xla_llvm_enable_alias_scope_metadata(bool value);

  public:
  // optional bool xla_llvm_enable_noalias_metadata = 71;
  bool has_xla_llvm_enable_noalias_metadata() const;
  void clear_xla_llvm_enable_noalias_metadata() ;
  bool xla_llvm_enable_noalias_metadata() const;
  void set_xla_llvm_enable_noalias_metadata(bool value);

  private:
  bool _internal_xla_llvm_enable_noalias_metadata() const;
  void _internal_set_xla_llvm_enable_noalias_metadata(bool value);

  public:
  // optional bool xla_llvm_enable_invariant_load_metadata = 72;
  bool has_xla_llvm_enable_invariant_load_metadata() const;
  void clear_xla_llvm_enable_invariant_load_metadata() ;
  bool xla_llvm_enable_invariant_load_metadata() const;
  void set_xla_llvm_enable_invariant_load_metadata(bool value);

  private:
  bool _internal_xla_llvm_enable_invariant_load_metadata() const;
  void _internal_set_xla_llvm_enable_invariant_load_metadata(bool value);

  public:
  // optional bool xla_llvm_disable_expensive_passes = 73;
  bool has_xla_llvm_disable_expensive_passes() const;
  void clear_xla_llvm_disable_expensive_passes() ;
  bool xla_llvm_disable_expensive_passes() const;
  void set_xla_llvm_disable_expensive_passes(bool value);

  private:
  bool _internal_xla_llvm_disable_expensive_passes() const;
  void _internal_set_xla_llvm_disable_expensive_passes(bool value);

  public:
  // optional bool xla_test_all_output_layouts = 90;
  bool has_xla_test_all_output_layouts() const;
  void clear_xla_test_all_output_layouts() ;
  bool xla_test_all_output_layouts() const;
  void set_xla_test_all_output_layouts(bool value);

  private:
  bool _internal_xla_test_all_output_layouts() const;
  void _internal_set_xla_test_all_output_layouts(bool value);

  public:
  // optional bool xla_test_all_input_layouts = 91;
  bool has_xla_test_all_input_layouts() const;
  void clear_xla_test_all_input_layouts() ;
  bool xla_test_all_input_layouts() const;
  void set_xla_test_all_input_layouts(bool value);

  private:
  bool _internal_xla_test_all_input_layouts() const;
  void _internal_set_xla_test_all_input_layouts(bool value);

  public:
  // optional bool xla_hlo_graph_sharding_color = 92;
  bool has_xla_hlo_graph_sharding_color() const;
  void clear_xla_hlo_graph_sharding_color() ;
  bool xla_hlo_graph_sharding_color() const;
  void set_xla_hlo_graph_sharding_color(bool value);

  private:
  bool _internal_xla_hlo_graph_sharding_color() const;
  void _internal_set_xla_hlo_graph_sharding_color(bool value);

  public:
  // optional bool xla_cpu_use_onednn = 97;
  bool has_xla_cpu_use_onednn() const;
  void clear_xla_cpu_use_onednn() ;
  bool xla_cpu_use_onednn() const;
  void set_xla_cpu_use_onednn(bool value);

  private:
  bool _internal_xla_cpu_use_onednn() const;
  void _internal_set_xla_cpu_use_onednn(bool value);

  public:
  // optional int32 xla_force_host_platform_device_count = 102;
  bool has_xla_force_host_platform_device_count() const;
  void clear_xla_force_host_platform_device_count() ;
  ::int32_t xla_force_host_platform_device_count() const;
  void set_xla_force_host_platform_device_count(::int32_t value);

  private:
  ::int32_t _internal_xla_force_host_platform_device_count() const;
  void _internal_set_xla_force_host_platform_device_count(::int32_t value);

  public:
  // optional .xla.DebugOptions.StepMarkerLocation xla_step_marker_location = 108;
  bool has_xla_step_marker_location() const;
  void clear_xla_step_marker_location() ;
  ::xla::DebugOptions_StepMarkerLocation xla_step_marker_location() const;
  void set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value);

  private:
  ::xla::DebugOptions_StepMarkerLocation _internal_xla_step_marker_location() const;
  void _internal_set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value);

  public:
  // optional bool xla_dump_hlo_as_text = 112;
  bool has_xla_dump_hlo_as_text() const;
  void clear_xla_dump_hlo_as_text() ;
  bool xla_dump_hlo_as_text() const;
  void set_xla_dump_hlo_as_text(bool value);

  private:
  bool _internal_xla_dump_hlo_as_text() const;
  void _internal_set_xla_dump_hlo_as_text(bool value);

  public:
  // optional bool xla_dump_hlo_as_proto = 113;
  bool has_xla_dump_hlo_as_proto() const;
  void clear_xla_dump_hlo_as_proto() ;
  bool xla_dump_hlo_as_proto() const;
  void set_xla_dump_hlo_as_proto(bool value);

  private:
  bool _internal_xla_dump_hlo_as_proto() const;
  void _internal_set_xla_dump_hlo_as_proto(bool value);

  public:
  // optional bool xla_dump_hlo_as_dot = 114;
  bool has_xla_dump_hlo_as_dot() const;
  void clear_xla_dump_hlo_as_dot() ;
  bool xla_dump_hlo_as_dot() const;
  void set_xla_dump_hlo_as_dot(bool value);

  private:
  bool _internal_xla_dump_hlo_as_dot() const;
  void _internal_set_xla_dump_hlo_as_dot(bool value);

  public:
  // optional bool xla_dump_hlo_as_url = 115;
  bool has_xla_dump_hlo_as_url() const;
  void clear_xla_dump_hlo_as_url() ;
  bool xla_dump_hlo_as_url() const;
  void set_xla_dump_hlo_as_url(bool value);

  private:
  bool _internal_xla_dump_hlo_as_url() const;
  void _internal_set_xla_dump_hlo_as_url(bool value);

  public:
  // optional bool xla_gpu_use_runtime_fusion = 181;
  bool has_xla_gpu_use_runtime_fusion() const;
  void clear_xla_gpu_use_runtime_fusion() ;
  bool xla_gpu_use_runtime_fusion() const;
  void set_xla_gpu_use_runtime_fusion(bool value);

  private:
  bool _internal_xla_gpu_use_runtime_fusion() const;
  void _internal_set_xla_gpu_use_runtime_fusion(bool value);

  public:
  // optional bool xla_gpu_verify_triton_fusion_numerics = 291;
  bool has_xla_gpu_verify_triton_fusion_numerics() const;
  void clear_xla_gpu_verify_triton_fusion_numerics() ;
  bool xla_gpu_verify_triton_fusion_numerics() const;
  void set_xla_gpu_verify_triton_fusion_numerics(bool value);

  private:
  bool _internal_xla_gpu_verify_triton_fusion_numerics() const;
  void _internal_set_xla_gpu_verify_triton_fusion_numerics(bool value);

  public:
  // optional bool xla_hlo_graph_addresses = 2;
  bool has_xla_hlo_graph_addresses() const;
  void clear_xla_hlo_graph_addresses() ;
  bool xla_hlo_graph_addresses() const;
  void set_xla_hlo_graph_addresses(bool value);

  private:
  bool _internal_xla_hlo_graph_addresses() const;
  void _internal_set_xla_hlo_graph_addresses(bool value);

  public:
  // optional bool xla_hlo_profile = 9;
  bool has_xla_hlo_profile() const;
  void clear_xla_hlo_profile() ;
  bool xla_hlo_profile() const;
  void set_xla_hlo_profile(bool value);

  private:
  bool _internal_xla_hlo_profile() const;
  void _internal_set_xla_hlo_profile(bool value);

  public:
  // optional int32 xla_gpu_autotune_level = 123;
  bool has_xla_gpu_autotune_level() const;
  void clear_xla_gpu_autotune_level() ;
  ::int32_t xla_gpu_autotune_level() const;
  void set_xla_gpu_autotune_level(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_autotune_level() const;
  void _internal_set_xla_gpu_autotune_level(::int32_t value);

  public:
  // optional bool xla_cpu_fast_math_honor_division = 126;
  bool has_xla_cpu_fast_math_honor_division() const;
  void clear_xla_cpu_fast_math_honor_division() ;
  bool xla_cpu_fast_math_honor_division() const;
  void set_xla_cpu_fast_math_honor_division(bool value);

  private:
  bool _internal_xla_cpu_fast_math_honor_division() const;
  void _internal_set_xla_cpu_fast_math_honor_division(bool value);

  public:
  // optional bool xla_cpu_fast_math_honor_functions = 129;
  bool has_xla_cpu_fast_math_honor_functions() const;
  void clear_xla_cpu_fast_math_honor_functions() ;
  bool xla_cpu_fast_math_honor_functions() const;
  void set_xla_cpu_fast_math_honor_functions(bool value);

  private:
  bool _internal_xla_cpu_fast_math_honor_functions() const;
  void _internal_set_xla_cpu_fast_math_honor_functions(bool value);

  public:
  // optional bool xla_cpu_fast_math_honor_infs = 121;
  bool has_xla_cpu_fast_math_honor_infs() const;
  void clear_xla_cpu_fast_math_honor_infs() ;
  bool xla_cpu_fast_math_honor_infs() const;
  void set_xla_cpu_fast_math_honor_infs(bool value);

  private:
  bool _internal_xla_cpu_fast_math_honor_infs() const;
  void _internal_set_xla_cpu_fast_math_honor_infs(bool value);

  public:
  // optional bool xla_cpu_fast_math_honor_nans = 120;
  bool has_xla_cpu_fast_math_honor_nans() const;
  void clear_xla_cpu_fast_math_honor_nans() ;
  bool xla_cpu_fast_math_honor_nans() const;
  void set_xla_cpu_fast_math_honor_nans(bool value);

  private:
  bool _internal_xla_cpu_fast_math_honor_nans() const;
  void _internal_set_xla_cpu_fast_math_honor_nans(bool value);

  public:
  // optional bool xla_dump_hlo_as_html = 116;
  bool has_xla_dump_hlo_as_html() const;
  void clear_xla_dump_hlo_as_html() ;
  bool xla_dump_hlo_as_html() const;
  void set_xla_dump_hlo_as_html(bool value);

  private:
  bool _internal_xla_dump_hlo_as_html() const;
  void _internal_set_xla_dump_hlo_as_html(bool value);

  public:
  // optional bool xla_dump_fusion_visualization = 149;
  bool has_xla_dump_fusion_visualization() const;
  void clear_xla_dump_fusion_visualization() ;
  bool xla_dump_fusion_visualization() const;
  void set_xla_dump_fusion_visualization(bool value);

  private:
  bool _internal_xla_dump_fusion_visualization() const;
  void _internal_set_xla_dump_fusion_visualization(bool value);

  public:
  // optional bool xla_dump_hlo_snapshots = 118;
  bool has_xla_dump_hlo_snapshots() const;
  void clear_xla_dump_hlo_snapshots() ;
  bool xla_dump_hlo_snapshots() const;
  void set_xla_dump_hlo_snapshots(bool value);

  private:
  bool _internal_xla_dump_hlo_snapshots() const;
  void _internal_set_xla_dump_hlo_snapshots(bool value);

  public:
  // optional bool xla_dump_include_timestamp = 131;
  bool has_xla_dump_include_timestamp() const;
  void clear_xla_dump_include_timestamp() ;
  bool xla_dump_include_timestamp() const;
  void set_xla_dump_include_timestamp(bool value);

  private:
  bool _internal_xla_dump_include_timestamp() const;
  void _internal_set_xla_dump_include_timestamp(bool value);

  public:
  // optional int32 xla_dump_max_hlo_modules = 132;
  bool has_xla_dump_max_hlo_modules() const;
  void clear_xla_dump_max_hlo_modules() ;
  ::int32_t xla_dump_max_hlo_modules() const;
  void set_xla_dump_max_hlo_modules(::int32_t value);

  private:
  ::int32_t _internal_xla_dump_max_hlo_modules() const;
  void _internal_set_xla_dump_max_hlo_modules(::int32_t value);

  public:
  // optional int32 xla_multiheap_size_constraint_per_heap = 142;
  bool has_xla_multiheap_size_constraint_per_heap() const;
  void clear_xla_multiheap_size_constraint_per_heap() ;
  ::int32_t xla_multiheap_size_constraint_per_heap() const;
  void set_xla_multiheap_size_constraint_per_heap(::int32_t value);

  private:
  ::int32_t _internal_xla_multiheap_size_constraint_per_heap() const;
  void _internal_set_xla_multiheap_size_constraint_per_heap(::int32_t value);

  public:
  // optional bool xla_gpu_force_conv_nchw = 125;
  bool has_xla_gpu_force_conv_nchw() const;
  void clear_xla_gpu_force_conv_nchw() ;
  bool xla_gpu_force_conv_nchw() const;
  void set_xla_gpu_force_conv_nchw(bool value);

  private:
  bool _internal_xla_gpu_force_conv_nchw() const;
  void _internal_set_xla_gpu_force_conv_nchw(bool value);

  public:
  // optional bool xla_gpu_force_conv_nhwc = 146;
  bool has_xla_gpu_force_conv_nhwc() const;
  void clear_xla_gpu_force_conv_nhwc() ;
  bool xla_gpu_force_conv_nhwc() const;
  void set_xla_gpu_force_conv_nhwc(bool value);

  private:
  bool _internal_xla_gpu_force_conv_nhwc() const;
  void _internal_set_xla_gpu_force_conv_nhwc(bool value);

  public:
  // optional bool xla_gpu_ftz = 62;
  bool has_xla_gpu_ftz() const;
  void clear_xla_gpu_ftz() ;
  bool xla_gpu_ftz() const;
  void set_xla_gpu_ftz(bool value);

  private:
  bool _internal_xla_gpu_ftz() const;
  void _internal_set_xla_gpu_ftz(bool value);

  public:
  // optional bool xla_gpu_fused_attention_use_cudnn_rng = 235;
  bool has_xla_gpu_fused_attention_use_cudnn_rng() const;
  void clear_xla_gpu_fused_attention_use_cudnn_rng() ;
  bool xla_gpu_fused_attention_use_cudnn_rng() const;
  void set_xla_gpu_fused_attention_use_cudnn_rng(bool value);

  private:
  bool _internal_xla_gpu_fused_attention_use_cudnn_rng() const;
  void _internal_set_xla_gpu_fused_attention_use_cudnn_rng(bool value);

  public:
  // optional int32 xla_gpu_force_compilation_parallelism = 147;
  bool has_xla_gpu_force_compilation_parallelism() const;
  void clear_xla_gpu_force_compilation_parallelism() ;
  ::int32_t xla_gpu_force_compilation_parallelism() const;
  void set_xla_gpu_force_compilation_parallelism(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_force_compilation_parallelism() const;
  void _internal_set_xla_gpu_force_compilation_parallelism(::int32_t value);

  public:
  // optional int32 xla_gpu_all_reduce_blueconnect_num_devices_per_host = 159;
  bool has_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const;
  void clear_xla_gpu_all_reduce_blueconnect_num_devices_per_host() ;
  ::int32_t xla_gpu_all_reduce_blueconnect_num_devices_per_host() const;
  void set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const;
  void _internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(::int32_t value);

  public:
  // optional int64 xla_gpu_all_reduce_combine_threshold_bytes = 157;
  bool has_xla_gpu_all_reduce_combine_threshold_bytes() const;
  void clear_xla_gpu_all_reduce_combine_threshold_bytes() ;
  ::int64_t xla_gpu_all_reduce_combine_threshold_bytes() const;
  void set_xla_gpu_all_reduce_combine_threshold_bytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_all_reduce_combine_threshold_bytes() const;
  void _internal_set_xla_gpu_all_reduce_combine_threshold_bytes(::int64_t value);

  public:
  // optional bool xla_dump_module_metadata = 144;
  bool has_xla_dump_module_metadata() const;
  void clear_xla_dump_module_metadata() ;
  bool xla_dump_module_metadata() const;
  void set_xla_dump_module_metadata(bool value);

  private:
  bool _internal_xla_dump_module_metadata() const;
  void _internal_set_xla_dump_module_metadata(bool value);

  public:
  // optional bool xla_dump_compress_protos = 151;
  bool has_xla_dump_compress_protos() const;
  void clear_xla_dump_compress_protos() ;
  bool xla_dump_compress_protos() const;
  void set_xla_dump_compress_protos(bool value);

  private:
  bool _internal_xla_dump_compress_protos() const;
  void _internal_set_xla_dump_compress_protos(bool value);

  public:
  // optional bool xla_dump_hlo_as_long_text = 164;
  bool has_xla_dump_hlo_as_long_text() const;
  void clear_xla_dump_hlo_as_long_text() ;
  bool xla_dump_hlo_as_long_text() const;
  void set_xla_dump_hlo_as_long_text(bool value);

  private:
  bool _internal_xla_dump_hlo_as_long_text() const;
  void _internal_set_xla_dump_hlo_as_long_text(bool value);

  public:
  // optional bool xla_dump_enable_mlir_pretty_form = 185;
  bool has_xla_dump_enable_mlir_pretty_form() const;
  void clear_xla_dump_enable_mlir_pretty_form() ;
  bool xla_dump_enable_mlir_pretty_form() const;
  void set_xla_dump_enable_mlir_pretty_form(bool value);

  private:
  bool _internal_xla_dump_enable_mlir_pretty_form() const;
  void _internal_set_xla_dump_enable_mlir_pretty_form(bool value);

  public:
  // optional .xla.DebugOptions.ShapeChecks xla_gpu_shape_checks = 170;
  bool has_xla_gpu_shape_checks() const;
  void clear_xla_gpu_shape_checks() ;
  ::xla::DebugOptions_ShapeChecks xla_gpu_shape_checks() const;
  void set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value);

  private:
  ::xla::DebugOptions_ShapeChecks _internal_xla_gpu_shape_checks() const;
  void _internal_set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value);

  public:
  // optional int64 xla_gpu_nccl_termination_timeout_seconds = 163;
  bool has_xla_gpu_nccl_termination_timeout_seconds() const;
  void clear_xla_gpu_nccl_termination_timeout_seconds() ;
  ::int64_t xla_gpu_nccl_termination_timeout_seconds() const;
  void set_xla_gpu_nccl_termination_timeout_seconds(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_nccl_termination_timeout_seconds() const;
  void _internal_set_xla_gpu_nccl_termination_timeout_seconds(::int64_t value);

  public:
  // optional int64 xla_gpu_redzone_scratch_max_megabytes = 167;
  bool has_xla_gpu_redzone_scratch_max_megabytes() const;
  void clear_xla_gpu_redzone_scratch_max_megabytes() ;
  ::int64_t xla_gpu_redzone_scratch_max_megabytes() const;
  void set_xla_gpu_redzone_scratch_max_megabytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_redzone_scratch_max_megabytes() const;
  void _internal_set_xla_gpu_redzone_scratch_max_megabytes(::int64_t value);

  public:
  // optional bool xla_gpu_enable_custom_fusions = 263;
  bool has_xla_gpu_enable_custom_fusions() const;
  void clear_xla_gpu_enable_custom_fusions() ;
  bool xla_gpu_enable_custom_fusions() const;
  void set_xla_gpu_enable_custom_fusions(bool value);

  private:
  bool _internal_xla_gpu_enable_custom_fusions() const;
  void _internal_set_xla_gpu_enable_custom_fusions(bool value);

  public:
  // optional bool xla_gpu_enable_dynamic_slice_fusion = 105;
  bool has_xla_gpu_enable_dynamic_slice_fusion() const;
  void clear_xla_gpu_enable_dynamic_slice_fusion() ;
  bool xla_gpu_enable_dynamic_slice_fusion() const;
  void set_xla_gpu_enable_dynamic_slice_fusion(bool value);

  private:
  bool _internal_xla_gpu_enable_dynamic_slice_fusion() const;
  void _internal_set_xla_gpu_enable_dynamic_slice_fusion(bool value);

  public:
  // optional bool xla_gpu_enable_fast_min_max = 100;
  bool has_xla_gpu_enable_fast_min_max() const;
  void clear_xla_gpu_enable_fast_min_max() ;
  bool xla_gpu_enable_fast_min_max() const;
  void set_xla_gpu_enable_fast_min_max(bool value);

  private:
  bool _internal_xla_gpu_enable_fast_min_max() const;
  void _internal_set_xla_gpu_enable_fast_min_max(bool value);

  public:
  // optional bool xla_gpu_enable_highest_priority_async_stream = 216;
  bool has_xla_gpu_enable_highest_priority_async_stream() const;
  void clear_xla_gpu_enable_highest_priority_async_stream() ;
  bool xla_gpu_enable_highest_priority_async_stream() const;
  void set_xla_gpu_enable_highest_priority_async_stream(bool value);

  private:
  bool _internal_xla_gpu_enable_highest_priority_async_stream() const;
  void _internal_set_xla_gpu_enable_highest_priority_async_stream(bool value);

  public:
  // optional bool xla_allow_excess_precision = 122;
  bool has_xla_allow_excess_precision() const;
  void clear_xla_allow_excess_precision() ;
  bool xla_allow_excess_precision() const;
  void set_xla_allow_excess_precision(bool value);

  private:
  bool _internal_xla_allow_excess_precision() const;
  void _internal_set_xla_allow_excess_precision(bool value);

  public:
  // optional bool xla_hlo_evaluator_use_fast_path = 106;
  bool has_xla_hlo_evaluator_use_fast_path() const;
  void clear_xla_hlo_evaluator_use_fast_path() ;
  bool xla_hlo_evaluator_use_fast_path() const;
  void set_xla_hlo_evaluator_use_fast_path(bool value);

  private:
  bool _internal_xla_hlo_evaluator_use_fast_path() const;
  void _internal_set_xla_hlo_evaluator_use_fast_path(bool value);

  public:
  // optional bool xla_allow_scalar_index_dynamic_ops = 107;
  bool has_xla_allow_scalar_index_dynamic_ops() const;
  void clear_xla_allow_scalar_index_dynamic_ops() ;
  bool xla_allow_scalar_index_dynamic_ops() const;
  void set_xla_allow_scalar_index_dynamic_ops(bool value);

  private:
  bool _internal_xla_allow_scalar_index_dynamic_ops() const;
  void _internal_set_xla_allow_scalar_index_dynamic_ops(bool value);

  public:
  // optional bool xla_flags_reset = 364;
  bool has_xla_flags_reset() const;
  void clear_xla_flags_reset() ;
  bool xla_flags_reset() const;
  void set_xla_flags_reset(bool value);

  private:
  bool _internal_xla_flags_reset() const;
  void _internal_set_xla_flags_reset(bool value);

  public:
  // optional bool xla_gpu_copy_insertion_use_region_analysis = 236;
  bool has_xla_gpu_copy_insertion_use_region_analysis() const;
  void clear_xla_gpu_copy_insertion_use_region_analysis() ;
  bool xla_gpu_copy_insertion_use_region_analysis() const;
  void set_xla_gpu_copy_insertion_use_region_analysis(bool value);

  private:
  bool _internal_xla_gpu_copy_insertion_use_region_analysis() const;
  void _internal_set_xla_gpu_copy_insertion_use_region_analysis(bool value);

  public:
  // optional bool xla_gpu_crash_on_verification_failures = 101;
  bool has_xla_gpu_crash_on_verification_failures() const;
  void clear_xla_gpu_crash_on_verification_failures() ;
  bool xla_gpu_crash_on_verification_failures() const;
  void set_xla_gpu_crash_on_verification_failures(bool value);

  private:
  bool _internal_xla_gpu_crash_on_verification_failures() const;
  void _internal_set_xla_gpu_crash_on_verification_failures(bool value);

  public:
  // optional bool xla_gpu_cublas_fallback = 247;
  bool has_xla_gpu_cublas_fallback() const;
  void clear_xla_gpu_cublas_fallback() ;
  bool xla_gpu_cublas_fallback() const;
  void set_xla_gpu_cublas_fallback(bool value);

  private:
  bool _internal_xla_gpu_cublas_fallback() const;
  void _internal_set_xla_gpu_cublas_fallback(bool value);

  public:
  // optional bool xla_gpu_deterministic_ops = 148;
  bool has_xla_gpu_deterministic_ops() const;
  void clear_xla_gpu_deterministic_ops() ;
  bool xla_gpu_deterministic_ops() const;
  void set_xla_gpu_deterministic_ops(bool value);

  private:
  bool _internal_xla_gpu_deterministic_ops() const;
  void _internal_set_xla_gpu_deterministic_ops(bool value);

  public:
  // optional .xla.DebugOptions.PartitioningAlgorithm xla_partitioning_algorithm = 187;
  bool has_xla_partitioning_algorithm() const;
  void clear_xla_partitioning_algorithm() ;
  ::xla::DebugOptions_PartitioningAlgorithm xla_partitioning_algorithm() const;
  void set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value);

  private:
  ::xla::DebugOptions_PartitioningAlgorithm _internal_xla_partitioning_algorithm() const;
  void _internal_set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value);

  public:
  // optional bool xla_dump_full_hlo_config = 381;
  bool has_xla_dump_full_hlo_config() const;
  void clear_xla_dump_full_hlo_config() ;
  bool xla_dump_full_hlo_config() const;
  void set_xla_dump_full_hlo_config(bool value);

  private:
  bool _internal_xla_dump_full_hlo_config() const;
  void _internal_set_xla_dump_full_hlo_config(bool value);

  public:
  // optional bool xla_tpu_detect_nan = 135;
  bool has_xla_tpu_detect_nan() const;
  void clear_xla_tpu_detect_nan() ;
  bool xla_tpu_detect_nan() const;
  void set_xla_tpu_detect_nan(bool value);

  private:
  bool _internal_xla_tpu_detect_nan() const;
  void _internal_set_xla_tpu_detect_nan(bool value);

  public:
  // optional bool xla_tpu_detect_inf = 136;
  bool has_xla_tpu_detect_inf() const;
  void clear_xla_tpu_detect_inf() ;
  bool xla_tpu_detect_inf() const;
  void set_xla_tpu_detect_inf(bool value);

  private:
  bool _internal_xla_tpu_detect_inf() const;
  void _internal_set_xla_tpu_detect_inf(bool value);

  public:
  // optional bool xla_cpu_enable_xprof_traceme = 137;
  bool has_xla_cpu_enable_xprof_traceme() const;
  void clear_xla_cpu_enable_xprof_traceme() ;
  bool xla_cpu_enable_xprof_traceme() const;
  void set_xla_cpu_enable_xprof_traceme(bool value);

  private:
  bool _internal_xla_cpu_enable_xprof_traceme() const;
  void _internal_set_xla_cpu_enable_xprof_traceme(bool value);

  public:
  // optional int32 xla_gpu_collective_inflation_factor = 205;
  bool has_xla_gpu_collective_inflation_factor() const;
  void clear_xla_gpu_collective_inflation_factor() ;
  ::int32_t xla_gpu_collective_inflation_factor() const;
  void set_xla_gpu_collective_inflation_factor(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_collective_inflation_factor() const;
  void _internal_set_xla_gpu_collective_inflation_factor(::int32_t value);

  public:
  // optional bool xla_cpu_use_acl = 174;
  bool has_xla_cpu_use_acl() const;
  void clear_xla_cpu_use_acl() ;
  bool xla_cpu_use_acl() const;
  void set_xla_cpu_use_acl(bool value);

  private:
  bool _internal_xla_cpu_use_acl() const;
  void _internal_set_xla_cpu_use_acl(bool value);

  public:
  // optional bool xla_cpu_strict_dot_conv_math = 175;
  bool has_xla_cpu_strict_dot_conv_math() const;
  void clear_xla_cpu_strict_dot_conv_math() ;
  bool xla_cpu_strict_dot_conv_math() const;
  void set_xla_cpu_strict_dot_conv_math(bool value);

  private:
  bool _internal_xla_cpu_strict_dot_conv_math() const;
  void _internal_set_xla_cpu_strict_dot_conv_math(bool value);

  public:
  // optional bool xla_dump_latency_hiding_schedule = 182;
  bool has_xla_dump_latency_hiding_schedule() const;
  void clear_xla_dump_latency_hiding_schedule() ;
  bool xla_dump_latency_hiding_schedule() const;
  void set_xla_dump_latency_hiding_schedule(bool value);

  private:
  bool _internal_xla_dump_latency_hiding_schedule() const;
  void _internal_set_xla_dump_latency_hiding_schedule(bool value);

  public:
  // optional bool xla_dump_large_constants = 290;
  bool has_xla_dump_large_constants() const;
  void clear_xla_dump_large_constants() ;
  bool xla_dump_large_constants() const;
  void set_xla_dump_large_constants(bool value);

  private:
  bool _internal_xla_dump_large_constants() const;
  void _internal_set_xla_dump_large_constants(bool value);

  public:
  // optional int32 xla_gpu_graph_min_graph_size = 208;
  bool has_xla_gpu_graph_min_graph_size() const;
  void clear_xla_gpu_graph_min_graph_size() ;
  ::int32_t xla_gpu_graph_min_graph_size() const;
  void set_xla_gpu_graph_min_graph_size(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_graph_min_graph_size() const;
  void _internal_set_xla_gpu_graph_min_graph_size(::int32_t value);

  public:
  // optional int64 xla_gpu_all_gather_combine_threshold_bytes = 212;
  bool has_xla_gpu_all_gather_combine_threshold_bytes() const;
  void clear_xla_gpu_all_gather_combine_threshold_bytes() ;
  ::int64_t xla_gpu_all_gather_combine_threshold_bytes() const;
  void set_xla_gpu_all_gather_combine_threshold_bytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_all_gather_combine_threshold_bytes() const;
  void _internal_set_xla_gpu_all_gather_combine_threshold_bytes(::int64_t value);

  public:
  // optional bool xla_gpu_disable_gpuasm_optimizations = 103;
  bool has_xla_gpu_disable_gpuasm_optimizations() const;
  void clear_xla_gpu_disable_gpuasm_optimizations() ;
  bool xla_gpu_disable_gpuasm_optimizations() const;
  void set_xla_gpu_disable_gpuasm_optimizations(bool value);

  private:
  bool _internal_xla_gpu_disable_gpuasm_optimizations() const;
  void _internal_set_xla_gpu_disable_gpuasm_optimizations(bool value);

  public:
  // optional bool xla_gpu_dump_autotuned_gemm_fusions = 232;
  bool has_xla_gpu_dump_autotuned_gemm_fusions() const;
  void clear_xla_gpu_dump_autotuned_gemm_fusions() ;
  bool xla_gpu_dump_autotuned_gemm_fusions() const;
  void set_xla_gpu_dump_autotuned_gemm_fusions(bool value);

  private:
  bool _internal_xla_gpu_dump_autotuned_gemm_fusions() const;
  void _internal_set_xla_gpu_dump_autotuned_gemm_fusions(bool value);

  public:
  // optional bool xla_gpu_dump_hlo_unoptimized_snapshots = 352;
  bool has_xla_gpu_dump_hlo_unoptimized_snapshots() const;
  void clear_xla_gpu_dump_hlo_unoptimized_snapshots() ;
  bool xla_gpu_dump_hlo_unoptimized_snapshots() const;
  void set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value);

  private:
  bool _internal_xla_gpu_dump_hlo_unoptimized_snapshots() const;
  void _internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value);

  public:
  // optional bool xla_gpu_dump_llvmir = 155;
  bool has_xla_gpu_dump_llvmir() const;
  void clear_xla_gpu_dump_llvmir() ;
  bool xla_gpu_dump_llvmir() const;
  void set_xla_gpu_dump_llvmir(bool value);

  private:
  bool _internal_xla_gpu_dump_llvmir() const;
  void _internal_set_xla_gpu_dump_llvmir(bool value);

  public:
  // optional bool xla_gpu_enable_shared_constants = 165;
  bool has_xla_gpu_enable_shared_constants() const;
  void clear_xla_gpu_enable_shared_constants() ;
  bool xla_gpu_enable_shared_constants() const;
  void set_xla_gpu_enable_shared_constants(bool value);

  private:
  bool _internal_xla_gpu_enable_shared_constants() const;
  void _internal_set_xla_gpu_enable_shared_constants(bool value);

  public:
  // optional bool xla_gpu_enable_split_k_autotuning = 241;
  bool has_xla_gpu_enable_split_k_autotuning() const;
  void clear_xla_gpu_enable_split_k_autotuning() ;
  bool xla_gpu_enable_split_k_autotuning() const;
  void set_xla_gpu_enable_split_k_autotuning(bool value);

  private:
  bool _internal_xla_gpu_enable_split_k_autotuning() const;
  void _internal_set_xla_gpu_enable_split_k_autotuning(bool value);

  public:
  // optional bool xla_gpu_enable_triton_gemm = 188;
  bool has_xla_gpu_enable_triton_gemm() const;
  void clear_xla_gpu_enable_triton_gemm() ;
  bool xla_gpu_enable_triton_gemm() const;
  void set_xla_gpu_enable_triton_gemm(bool value);

  private:
  bool _internal_xla_gpu_enable_triton_gemm() const;
  void _internal_set_xla_gpu_enable_triton_gemm(bool value);

  public:
  // optional bool xla_gpu_enable_triton_hopper = 266;
  bool has_xla_gpu_enable_triton_hopper() const;
  void clear_xla_gpu_enable_triton_hopper() ;
  bool xla_gpu_enable_triton_hopper() const;
  void set_xla_gpu_enable_triton_hopper(bool value);

  private:
  bool _internal_xla_gpu_enable_triton_hopper() const;
  void _internal_set_xla_gpu_enable_triton_hopper(bool value);

  public:
  // optional int64 xla_gpu_reduce_scatter_combine_threshold_bytes = 213;
  bool has_xla_gpu_reduce_scatter_combine_threshold_bytes() const;
  void clear_xla_gpu_reduce_scatter_combine_threshold_bytes() ;
  ::int64_t xla_gpu_reduce_scatter_combine_threshold_bytes() const;
  void set_xla_gpu_reduce_scatter_combine_threshold_bytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_reduce_scatter_combine_threshold_bytes() const;
  void _internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(::int64_t value);

  public:
  // optional bool xla_gpu_enable_cub_radix_sort = 259;
  bool has_xla_gpu_enable_cub_radix_sort() const;
  void clear_xla_gpu_enable_cub_radix_sort() ;
  bool xla_gpu_enable_cub_radix_sort() const;
  void set_xla_gpu_enable_cub_radix_sort(bool value);

  private:
  bool _internal_xla_gpu_enable_cub_radix_sort() const;
  void _internal_set_xla_gpu_enable_cub_radix_sort(bool value);

  public:
  // optional bool xla_gpu_enable_cublaslt = 166;
  bool has_xla_gpu_enable_cublaslt() const;
  void clear_xla_gpu_enable_cublaslt() ;
  bool xla_gpu_enable_cublaslt() const;
  void set_xla_gpu_enable_cublaslt(bool value);

  private:
  bool _internal_xla_gpu_enable_cublaslt() const;
  void _internal_set_xla_gpu_enable_cublaslt(bool value);

  public:
  // optional bool xla_gpu_enable_cudnn_int8x32_convolution_reordering = 189;
  bool has_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const;
  void clear_xla_gpu_enable_cudnn_int8x32_convolution_reordering() ;
  bool xla_gpu_enable_cudnn_int8x32_convolution_reordering() const;
  void set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value);

  private:
  bool _internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const;
  void _internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value);

  public:
  // optional bool xla_gpu_enable_cudnn_layer_norm = 262;
  bool has_xla_gpu_enable_cudnn_layer_norm() const;
  void clear_xla_gpu_enable_cudnn_layer_norm() ;
  bool xla_gpu_enable_cudnn_layer_norm() const;
  void set_xla_gpu_enable_cudnn_layer_norm(bool value);

  private:
  bool _internal_xla_gpu_enable_cudnn_layer_norm() const;
  void _internal_set_xla_gpu_enable_cudnn_layer_norm(bool value);

  public:
  // optional bool xla_cpu_copy_insertion_use_region_analysis = 337;
  bool has_xla_cpu_copy_insertion_use_region_analysis() const;
  void clear_xla_cpu_copy_insertion_use_region_analysis() ;
  bool xla_cpu_copy_insertion_use_region_analysis() const;
  void set_xla_cpu_copy_insertion_use_region_analysis(bool value);

  private:
  bool _internal_xla_cpu_copy_insertion_use_region_analysis() const;
  void _internal_set_xla_cpu_copy_insertion_use_region_analysis(bool value);

  public:
  // optional bool xla_cpu_enable_concurrency_optimized_scheduler = 307;
  bool has_xla_cpu_enable_concurrency_optimized_scheduler() const;
  void clear_xla_cpu_enable_concurrency_optimized_scheduler() ;
  bool xla_cpu_enable_concurrency_optimized_scheduler() const;
  void set_xla_cpu_enable_concurrency_optimized_scheduler(bool value);

  private:
  bool _internal_xla_cpu_enable_concurrency_optimized_scheduler() const;
  void _internal_set_xla_cpu_enable_concurrency_optimized_scheduler(bool value);

  public:
  // optional bool xla_cpu_enable_fast_math = 99;
  bool has_xla_cpu_enable_fast_math() const;
  void clear_xla_cpu_enable_fast_math() ;
  bool xla_cpu_enable_fast_math() const;
  void set_xla_cpu_enable_fast_math(bool value);

  private:
  bool _internal_xla_cpu_enable_fast_math() const;
  void _internal_set_xla_cpu_enable_fast_math(bool value);

  public:
  // optional bool xla_cpu_enable_fast_min_max = 140;
  bool has_xla_cpu_enable_fast_min_max() const;
  void clear_xla_cpu_enable_fast_min_max() ;
  bool xla_cpu_enable_fast_min_max() const;
  void set_xla_cpu_enable_fast_min_max(bool value);

  private:
  bool _internal_xla_cpu_enable_fast_min_max() const;
  void _internal_set_xla_cpu_enable_fast_min_max(bool value);

  public:
  // optional int32 xla_gpu_auto_spmd_partitioning_memory_budget_gb = 224;
  bool has_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const;
  void clear_xla_gpu_auto_spmd_partitioning_memory_budget_gb() ;
  ::int32_t xla_gpu_auto_spmd_partitioning_memory_budget_gb() const;
  void set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const;
  void _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(::int32_t value);

  public:
  // optional float xla_gpu_auto_spmd_partitioning_memory_budget_ratio = 225;
  bool has_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const;
  void clear_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() ;
  float xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const;
  void set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value);

  private:
  float _internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const;
  void _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value);

  public:
  // optional int64 xla_gpu_redzone_padding_bytes = 228;
  bool has_xla_gpu_redzone_padding_bytes() const;
  void clear_xla_gpu_redzone_padding_bytes() ;
  ::int64_t xla_gpu_redzone_padding_bytes() const;
  void set_xla_gpu_redzone_padding_bytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_redzone_padding_bytes() const;
  void _internal_set_xla_gpu_redzone_padding_bytes(::int64_t value);

  public:
  // optional bool xla_gpu_enable_pipelined_all_reduce = 217;
  bool has_xla_gpu_enable_pipelined_all_reduce() const;
  void clear_xla_gpu_enable_pipelined_all_reduce() ;
  bool xla_gpu_enable_pipelined_all_reduce() const;
  void set_xla_gpu_enable_pipelined_all_reduce(bool value);

  private:
  bool _internal_xla_gpu_enable_pipelined_all_reduce() const;
  void _internal_set_xla_gpu_enable_pipelined_all_reduce(bool value);

  public:
  // optional bool xla_gpu_enable_pipelined_collectives = 239 [deprecated = true];
  [[deprecated]]  bool has_xla_gpu_enable_pipelined_collectives() const;
  [[deprecated]]  void clear_xla_gpu_enable_pipelined_collectives() ;
  [[deprecated]] bool xla_gpu_enable_pipelined_collectives() const;
  [[deprecated]] void set_xla_gpu_enable_pipelined_collectives(bool value);

  private:
  bool _internal_xla_gpu_enable_pipelined_collectives() const;
  void _internal_set_xla_gpu_enable_pipelined_collectives(bool value);

  public:
  // optional bool xla_gpu_enable_pipelined_p2p = 246;
  bool has_xla_gpu_enable_pipelined_p2p() const;
  void clear_xla_gpu_enable_pipelined_p2p() ;
  bool xla_gpu_enable_pipelined_p2p() const;
  void set_xla_gpu_enable_pipelined_p2p(bool value);

  private:
  bool _internal_xla_gpu_enable_pipelined_p2p() const;
  void _internal_set_xla_gpu_enable_pipelined_p2p(bool value);

  public:
  // optional bool xla_gpu_enable_pipelined_reduce_scatter = 231;
  bool has_xla_gpu_enable_pipelined_reduce_scatter() const;
  void clear_xla_gpu_enable_pipelined_reduce_scatter() ;
  bool xla_gpu_enable_pipelined_reduce_scatter() const;
  void set_xla_gpu_enable_pipelined_reduce_scatter(bool value);

  private:
  bool _internal_xla_gpu_enable_pipelined_reduce_scatter() const;
  void _internal_set_xla_gpu_enable_pipelined_reduce_scatter(bool value);

  public:
  // optional bool xla_detailed_logging = 252;
  bool has_xla_detailed_logging() const;
  void clear_xla_detailed_logging() ;
  bool xla_detailed_logging() const;
  void set_xla_detailed_logging(bool value);

  private:
  bool _internal_xla_detailed_logging() const;
  void _internal_set_xla_detailed_logging(bool value);

  public:
  // optional bool xla_enable_dumping = 253;
  bool has_xla_enable_dumping() const;
  void clear_xla_enable_dumping() ;
  bool xla_enable_dumping() const;
  void set_xla_enable_dumping(bool value);

  private:
  bool _internal_xla_enable_dumping() const;
  void _internal_set_xla_enable_dumping(bool value);

  public:
  // optional bool xla_llvm_force_inline_before_split = 300;
  bool has_xla_llvm_force_inline_before_split() const;
  void clear_xla_llvm_force_inline_before_split() ;
  bool xla_llvm_force_inline_before_split() const;
  void set_xla_llvm_force_inline_before_split(bool value);

  private:
  bool _internal_xla_llvm_force_inline_before_split() const;
  void _internal_set_xla_llvm_force_inline_before_split(bool value);

  public:
  // optional bool xla_dump_disable_metadata = 153;
  bool has_xla_dump_disable_metadata() const;
  void clear_xla_dump_disable_metadata() ;
  bool xla_dump_disable_metadata() const;
  void set_xla_dump_disable_metadata(bool value);

  private:
  bool _internal_xla_dump_disable_metadata() const;
  void _internal_set_xla_dump_disable_metadata(bool value);

  public:
  // optional int64 xla_gpu_collective_permute_decomposer_threshold = 237;
  bool has_xla_gpu_collective_permute_decomposer_threshold() const;
  void clear_xla_gpu_collective_permute_decomposer_threshold() ;
  ::int64_t xla_gpu_collective_permute_decomposer_threshold() const;
  void set_xla_gpu_collective_permute_decomposer_threshold(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_collective_permute_decomposer_threshold() const;
  void _internal_set_xla_gpu_collective_permute_decomposer_threshold(::int64_t value);

  public:
  // optional bool xla_gpu_enable_while_loop_double_buffering = 248;
  bool has_xla_gpu_enable_while_loop_double_buffering() const;
  void clear_xla_gpu_enable_while_loop_double_buffering() ;
  bool xla_gpu_enable_while_loop_double_buffering() const;
  void set_xla_gpu_enable_while_loop_double_buffering(bool value);

  private:
  bool _internal_xla_gpu_enable_while_loop_double_buffering() const;
  void _internal_set_xla_gpu_enable_while_loop_double_buffering(bool value);

  public:
  // optional bool xla_gpu_enable_while_loop_reduce_scatter_code_motion = 203;
  bool has_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const;
  void clear_xla_gpu_enable_while_loop_reduce_scatter_code_motion() ;
  bool xla_gpu_enable_while_loop_reduce_scatter_code_motion() const;
  void set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value);

  private:
  bool _internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const;
  void _internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value);

  public:
  // optional bool xla_gpu_exclude_nondeterministic_ops = 297;
  bool has_xla_gpu_exclude_nondeterministic_ops() const;
  void clear_xla_gpu_exclude_nondeterministic_ops() ;
  bool xla_gpu_exclude_nondeterministic_ops() const;
  void set_xla_gpu_exclude_nondeterministic_ops(bool value);

  private:
  bool _internal_xla_gpu_exclude_nondeterministic_ops() const;
  void _internal_set_xla_gpu_exclude_nondeterministic_ops(bool value);

  public:
  // optional bool xla_gpu_exhaustive_tiling_search = 219;
  bool has_xla_gpu_exhaustive_tiling_search() const;
  void clear_xla_gpu_exhaustive_tiling_search() ;
  bool xla_gpu_exhaustive_tiling_search() const;
  void set_xla_gpu_exhaustive_tiling_search(bool value);

  private:
  bool _internal_xla_gpu_exhaustive_tiling_search() const;
  void _internal_set_xla_gpu_exhaustive_tiling_search(bool value);

  public:
  // optional bool xla_gpu_temp_buffer_use_separate_color = 312;
  bool has_xla_gpu_temp_buffer_use_separate_color() const;
  void clear_xla_gpu_temp_buffer_use_separate_color() ;
  bool xla_gpu_temp_buffer_use_separate_color() const;
  void set_xla_gpu_temp_buffer_use_separate_color(bool value);

  private:
  bool _internal_xla_gpu_temp_buffer_use_separate_color() const;
  void _internal_set_xla_gpu_temp_buffer_use_separate_color(bool value);

  public:
  // optional bool xla_gpu_triton_gemm_any = 190;
  bool has_xla_gpu_triton_gemm_any() const;
  void clear_xla_gpu_triton_gemm_any() ;
  bool xla_gpu_triton_gemm_any() const;
  void set_xla_gpu_triton_gemm_any(bool value);

  private:
  bool _internal_xla_gpu_triton_gemm_any() const;
  void _internal_set_xla_gpu_triton_gemm_any(bool value);

  public:
  // optional bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found = 138;
  bool has_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const;
  void clear_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() ;
  bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const;
  void set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value);

  private:
  bool _internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const;
  void _internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value);

  public:
  // optional bool xla_gpu_unsupported_annotate_with_emitter_loc = 358;
  bool has_xla_gpu_unsupported_annotate_with_emitter_loc() const;
  void clear_xla_gpu_unsupported_annotate_with_emitter_loc() ;
  bool xla_gpu_unsupported_annotate_with_emitter_loc() const;
  void set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value);

  private:
  bool _internal_xla_gpu_unsupported_annotate_with_emitter_loc() const;
  void _internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value);

  public:
  // optional int64 xla_debug_buffer_assignment_show_max = 251;
  bool has_xla_debug_buffer_assignment_show_max() const;
  void clear_xla_debug_buffer_assignment_show_max() ;
  ::int64_t xla_debug_buffer_assignment_show_max() const;
  void set_xla_debug_buffer_assignment_show_max(::int64_t value);

  private:
  ::int64_t _internal_xla_debug_buffer_assignment_show_max() const;
  void _internal_set_xla_debug_buffer_assignment_show_max(::int64_t value);

  public:
  // optional bool xla_gpu_enable_nccl_clique_optimization = 244 [deprecated = true];
  [[deprecated]]  bool has_xla_gpu_enable_nccl_clique_optimization() const;
  [[deprecated]]  void clear_xla_gpu_enable_nccl_clique_optimization() ;
  [[deprecated]] bool xla_gpu_enable_nccl_clique_optimization() const;
  [[deprecated]] void set_xla_gpu_enable_nccl_clique_optimization(bool value);

  private:
  bool _internal_xla_gpu_enable_nccl_clique_optimization() const;
  void _internal_set_xla_gpu_enable_nccl_clique_optimization(bool value);

  public:
  // optional bool xla_gpu_enable_nccl_comm_splitting = 272;
  bool has_xla_gpu_enable_nccl_comm_splitting() const;
  void clear_xla_gpu_enable_nccl_comm_splitting() ;
  bool xla_gpu_enable_nccl_comm_splitting() const;
  void set_xla_gpu_enable_nccl_comm_splitting(bool value);

  private:
  bool _internal_xla_gpu_enable_nccl_comm_splitting() const;
  void _internal_set_xla_gpu_enable_nccl_comm_splitting(bool value);

  public:
  // optional bool xla_gpu_enable_nccl_user_buffers = 267;
  bool has_xla_gpu_enable_nccl_user_buffers() const;
  void clear_xla_gpu_enable_nccl_user_buffers() ;
  bool xla_gpu_enable_nccl_user_buffers() const;
  void set_xla_gpu_enable_nccl_user_buffers(bool value);

  private:
  bool _internal_xla_gpu_enable_nccl_user_buffers() const;
  void _internal_set_xla_gpu_enable_nccl_user_buffers(bool value);

  public:
  // optional bool xla_gpu_enable_pipelined_all_gather = 227;
  bool has_xla_gpu_enable_pipelined_all_gather() const;
  void clear_xla_gpu_enable_pipelined_all_gather() ;
  bool xla_gpu_enable_pipelined_all_gather() const;
  void set_xla_gpu_enable_pipelined_all_gather(bool value);

  private:
  bool _internal_xla_gpu_enable_pipelined_all_gather() const;
  void _internal_set_xla_gpu_enable_pipelined_all_gather(bool value);

  public:
  // optional bool xla_gpu_enable_host_memory_offloading = 296;
  bool has_xla_gpu_enable_host_memory_offloading() const;
  void clear_xla_gpu_enable_host_memory_offloading() ;
  bool xla_gpu_enable_host_memory_offloading() const;
  void set_xla_gpu_enable_host_memory_offloading(bool value);

  private:
  bool _internal_xla_gpu_enable_host_memory_offloading() const;
  void _internal_set_xla_gpu_enable_host_memory_offloading(bool value);

  public:
  // optional bool xla_gpu_enable_latency_hiding_scheduler = 186;
  bool has_xla_gpu_enable_latency_hiding_scheduler() const;
  void clear_xla_gpu_enable_latency_hiding_scheduler() ;
  bool xla_gpu_enable_latency_hiding_scheduler() const;
  void set_xla_gpu_enable_latency_hiding_scheduler(bool value);

  private:
  bool _internal_xla_gpu_enable_latency_hiding_scheduler() const;
  void _internal_set_xla_gpu_enable_latency_hiding_scheduler(bool value);

  public:
  // optional bool xla_gpu_enable_libnvptxcompiler = 269;
  bool has_xla_gpu_enable_libnvptxcompiler() const;
  void clear_xla_gpu_enable_libnvptxcompiler() ;
  bool xla_gpu_enable_libnvptxcompiler() const;
  void set_xla_gpu_enable_libnvptxcompiler(bool value);

  private:
  bool _internal_xla_gpu_enable_libnvptxcompiler() const;
  void _internal_set_xla_gpu_enable_libnvptxcompiler(bool value);

  public:
  // optional bool xla_gpu_enable_llvm_module_compilation_parallelism = 268;
  bool has_xla_gpu_enable_llvm_module_compilation_parallelism() const;
  void clear_xla_gpu_enable_llvm_module_compilation_parallelism() ;
  bool xla_gpu_enable_llvm_module_compilation_parallelism() const;
  void set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value);

  private:
  bool _internal_xla_gpu_enable_llvm_module_compilation_parallelism() const;
  void _internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value);

  public:
  // optional int32 xla_gpu_llvm_verification_level = 256;
  bool has_xla_gpu_llvm_verification_level() const;
  void clear_xla_gpu_llvm_verification_level() ;
  ::int32_t xla_gpu_llvm_verification_level() const;
  void set_xla_gpu_llvm_verification_level(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_llvm_verification_level() const;
  void _internal_set_xla_gpu_llvm_verification_level(::int32_t value);

  public:
  // optional int32 xla_gpu_memory_limit_slop_factor = 260;
  bool has_xla_gpu_memory_limit_slop_factor() const;
  void clear_xla_gpu_memory_limit_slop_factor() ;
  ::int32_t xla_gpu_memory_limit_slop_factor() const;
  void set_xla_gpu_memory_limit_slop_factor(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_memory_limit_slop_factor() const;
  void _internal_set_xla_gpu_memory_limit_slop_factor(::int32_t value);

  public:
  // optional int64 xla_gpu_threshold_for_windowed_einsum_mib = 265;
  bool has_xla_gpu_threshold_for_windowed_einsum_mib() const;
  void clear_xla_gpu_threshold_for_windowed_einsum_mib() ;
  ::int64_t xla_gpu_threshold_for_windowed_einsum_mib() const;
  void set_xla_gpu_threshold_for_windowed_einsum_mib(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_threshold_for_windowed_einsum_mib() const;
  void _internal_set_xla_gpu_threshold_for_windowed_einsum_mib(::int64_t value);

  public:
  // optional bool xla_gpu_enable_reassociation_for_converted_ar = 209;
  bool has_xla_gpu_enable_reassociation_for_converted_ar() const;
  void clear_xla_gpu_enable_reassociation_for_converted_ar() ;
  bool xla_gpu_enable_reassociation_for_converted_ar() const;
  void set_xla_gpu_enable_reassociation_for_converted_ar(bool value);

  private:
  bool _internal_xla_gpu_enable_reassociation_for_converted_ar() const;
  void _internal_set_xla_gpu_enable_reassociation_for_converted_ar(bool value);

  public:
  // optional bool xla_gpu_enable_reduce_scatter_combine_by_dim = 257;
  bool has_xla_gpu_enable_reduce_scatter_combine_by_dim() const;
  void clear_xla_gpu_enable_reduce_scatter_combine_by_dim() ;
  bool xla_gpu_enable_reduce_scatter_combine_by_dim() const;
  void set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value);

  private:
  bool _internal_xla_gpu_enable_reduce_scatter_combine_by_dim() const;
  void _internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value);

  public:
  // optional bool xla_gpu_enable_reduction_epilogue_fusion = 243;
  bool has_xla_gpu_enable_reduction_epilogue_fusion() const;
  void clear_xla_gpu_enable_reduction_epilogue_fusion() ;
  bool xla_gpu_enable_reduction_epilogue_fusion() const;
  void set_xla_gpu_enable_reduction_epilogue_fusion(bool value);

  private:
  bool _internal_xla_gpu_enable_reduction_epilogue_fusion() const;
  void _internal_set_xla_gpu_enable_reduction_epilogue_fusion(bool value);

  public:
  // optional bool xla_gpu_enable_scatter_determinism_expander = 345;
  bool has_xla_gpu_enable_scatter_determinism_expander() const;
  void clear_xla_gpu_enable_scatter_determinism_expander() ;
  bool xla_gpu_enable_scatter_determinism_expander() const;
  void set_xla_gpu_enable_scatter_determinism_expander(bool value);

  private:
  bool _internal_xla_gpu_enable_scatter_determinism_expander() const;
  void _internal_set_xla_gpu_enable_scatter_determinism_expander(bool value);

  public:
  // optional bool xla_gpu_require_complete_aot_autotune_results = 284;
  bool has_xla_gpu_require_complete_aot_autotune_results() const;
  void clear_xla_gpu_require_complete_aot_autotune_results() ;
  bool xla_gpu_require_complete_aot_autotune_results() const;
  void set_xla_gpu_require_complete_aot_autotune_results(bool value);

  private:
  bool _internal_xla_gpu_require_complete_aot_autotune_results() const;
  void _internal_set_xla_gpu_require_complete_aot_autotune_results(bool value);

  public:
  // optional bool xla_gpu_require_exclusive_lock = 347;
  bool has_xla_gpu_require_exclusive_lock() const;
  void clear_xla_gpu_require_exclusive_lock() ;
  bool xla_gpu_require_exclusive_lock() const;
  void set_xla_gpu_require_exclusive_lock(bool value);

  private:
  bool _internal_xla_gpu_require_exclusive_lock() const;
  void _internal_set_xla_gpu_require_exclusive_lock(bool value);

  public:
  // optional bool xla_gpu_shard_autotuning = 304;
  bool has_xla_gpu_shard_autotuning() const;
  void clear_xla_gpu_shard_autotuning() ;
  bool xla_gpu_shard_autotuning() const;
  void set_xla_gpu_shard_autotuning(bool value);

  private:
  bool _internal_xla_gpu_shard_autotuning() const;
  void _internal_set_xla_gpu_shard_autotuning(bool value);

  public:
  // optional bool xla_gpu_strict_conv_algorithm_picker = 156;
  bool has_xla_gpu_strict_conv_algorithm_picker() const;
  void clear_xla_gpu_strict_conv_algorithm_picker() ;
  bool xla_gpu_strict_conv_algorithm_picker() const;
  void set_xla_gpu_strict_conv_algorithm_picker(bool value);

  private:
  bool _internal_xla_gpu_strict_conv_algorithm_picker() const;
  void _internal_set_xla_gpu_strict_conv_algorithm_picker(bool value);

  public:
  // optional int64 xla_gpu_nccl_collective_max_nchannels = 273;
  bool has_xla_gpu_nccl_collective_max_nchannels() const;
  void clear_xla_gpu_nccl_collective_max_nchannels() ;
  ::int64_t xla_gpu_nccl_collective_max_nchannels() const;
  void set_xla_gpu_nccl_collective_max_nchannels(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_nccl_collective_max_nchannels() const;
  void _internal_set_xla_gpu_nccl_collective_max_nchannels(::int64_t value);

  public:
  // optional int64 xla_gpu_nccl_p2p_max_nchannels = 274;
  bool has_xla_gpu_nccl_p2p_max_nchannels() const;
  void clear_xla_gpu_nccl_p2p_max_nchannels() ;
  ::int64_t xla_gpu_nccl_p2p_max_nchannels() const;
  void set_xla_gpu_nccl_p2p_max_nchannels(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_nccl_p2p_max_nchannels() const;
  void _internal_set_xla_gpu_nccl_p2p_max_nchannels(::int64_t value);

  public:
  // optional int64 xla_gpu_nccl_init_max_rank_per_root_ratio = 277;
  bool has_xla_gpu_nccl_init_max_rank_per_root_ratio() const;
  void clear_xla_gpu_nccl_init_max_rank_per_root_ratio() ;
  ::int64_t xla_gpu_nccl_init_max_rank_per_root_ratio() const;
  void set_xla_gpu_nccl_init_max_rank_per_root_ratio(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_nccl_init_max_rank_per_root_ratio() const;
  void _internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(::int64_t value);

  public:
  // optional int64 xla_gpu_gemm_rewrite_size_threshold = 283;
  bool has_xla_gpu_gemm_rewrite_size_threshold() const;
  void clear_xla_gpu_gemm_rewrite_size_threshold() ;
  ::int64_t xla_gpu_gemm_rewrite_size_threshold() const;
  void set_xla_gpu_gemm_rewrite_size_threshold(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_gemm_rewrite_size_threshold() const;
  void _internal_set_xla_gpu_gemm_rewrite_size_threshold(::int64_t value);

  public:
  // optional int64 xla_gpu_autotune_max_solutions = 288;
  bool has_xla_gpu_autotune_max_solutions() const;
  void clear_xla_gpu_autotune_max_solutions() ;
  ::int64_t xla_gpu_autotune_max_solutions() const;
  void set_xla_gpu_autotune_max_solutions(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_autotune_max_solutions() const;
  void _internal_set_xla_gpu_autotune_max_solutions(::int64_t value);

  public:
  // optional int32 xla_gpu_cudnn_gemm_fusion_level = 285;
  bool has_xla_gpu_cudnn_gemm_fusion_level() const;
  void clear_xla_gpu_cudnn_gemm_fusion_level() ;
  ::int32_t xla_gpu_cudnn_gemm_fusion_level() const;
  void set_xla_gpu_cudnn_gemm_fusion_level(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_cudnn_gemm_fusion_level() const;
  void _internal_set_xla_gpu_cudnn_gemm_fusion_level(::int32_t value);

  public:
  // optional bool xla_gpu_generate_debug_info = 348;
  bool has_xla_gpu_generate_debug_info() const;
  void clear_xla_gpu_generate_debug_info() ;
  bool xla_gpu_generate_debug_info() const;
  void set_xla_gpu_generate_debug_info(bool value);

  private:
  bool _internal_xla_gpu_generate_debug_info() const;
  void _internal_set_xla_gpu_generate_debug_info(bool value);

  public:
  // optional bool xla_gpu_generate_line_info = 349;
  bool has_xla_gpu_generate_line_info() const;
  void clear_xla_gpu_generate_line_info() ;
  bool xla_gpu_generate_line_info() const;
  void set_xla_gpu_generate_line_info(bool value);

  private:
  bool _internal_xla_gpu_generate_line_info() const;
  void _internal_set_xla_gpu_generate_line_info(bool value);

  public:
  // optional bool xla_gpu_graph_enable_concurrent_region = 215;
  bool has_xla_gpu_graph_enable_concurrent_region() const;
  void clear_xla_gpu_graph_enable_concurrent_region() ;
  bool xla_gpu_graph_enable_concurrent_region() const;
  void set_xla_gpu_graph_enable_concurrent_region(bool value);

  private:
  bool _internal_xla_gpu_graph_enable_concurrent_region() const;
  void _internal_set_xla_gpu_graph_enable_concurrent_region(bool value);

  public:
  // optional bool xla_gpu_mock_custom_calls = 245;
  bool has_xla_gpu_mock_custom_calls() const;
  void clear_xla_gpu_mock_custom_calls() ;
  bool xla_gpu_mock_custom_calls() const;
  void set_xla_gpu_mock_custom_calls(bool value);

  private:
  bool _internal_xla_gpu_mock_custom_calls() const;
  void _internal_set_xla_gpu_mock_custom_calls(bool value);

  public:
  // optional bool xla_gpu_enable_all_gather_combine_by_dim = 254;
  bool has_xla_gpu_enable_all_gather_combine_by_dim() const;
  void clear_xla_gpu_enable_all_gather_combine_by_dim() ;
  bool xla_gpu_enable_all_gather_combine_by_dim() const;
  void set_xla_gpu_enable_all_gather_combine_by_dim(bool value);

  private:
  bool _internal_xla_gpu_enable_all_gather_combine_by_dim() const;
  void _internal_set_xla_gpu_enable_all_gather_combine_by_dim(bool value);

  public:
  // optional bool xla_gpu_enable_analytical_latency_estimator = 255;
  bool has_xla_gpu_enable_analytical_latency_estimator() const;
  void clear_xla_gpu_enable_analytical_latency_estimator() ;
  bool xla_gpu_enable_analytical_latency_estimator() const;
  void set_xla_gpu_enable_analytical_latency_estimator(bool value);

  private:
  bool _internal_xla_gpu_enable_analytical_latency_estimator() const;
  void _internal_set_xla_gpu_enable_analytical_latency_estimator(bool value);

  public:
  // optional bool xla_gpu_enable_analytical_sol_latency_estimator = 356;
  bool has_xla_gpu_enable_analytical_sol_latency_estimator() const;
  void clear_xla_gpu_enable_analytical_sol_latency_estimator() ;
  bool xla_gpu_enable_analytical_sol_latency_estimator() const;
  void set_xla_gpu_enable_analytical_sol_latency_estimator(bool value);

  private:
  bool _internal_xla_gpu_enable_analytical_sol_latency_estimator() const;
  void _internal_set_xla_gpu_enable_analytical_sol_latency_estimator(bool value);

  public:
  // optional bool xla_gpu_enable_approx_costly_collectives = 305;
  bool has_xla_gpu_enable_approx_costly_collectives() const;
  void clear_xla_gpu_enable_approx_costly_collectives() ;
  bool xla_gpu_enable_approx_costly_collectives() const;
  void set_xla_gpu_enable_approx_costly_collectives(bool value);

  private:
  bool _internal_xla_gpu_enable_approx_costly_collectives() const;
  void _internal_set_xla_gpu_enable_approx_costly_collectives(bool value);

  public:
  // optional .xla.DebugOptions.WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling = 294;
  bool has_xla_gpu_enable_while_loop_unrolling() const;
  void clear_xla_gpu_enable_while_loop_unrolling() ;
  ::xla::DebugOptions_WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling() const;
  void set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value);

  private:
  ::xla::DebugOptions_WhileLoopUnrolling _internal_xla_gpu_enable_while_loop_unrolling() const;
  void _internal_set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value);

  public:
  // optional int64 xla_reduce_window_rewrite_base_length = 293;
  bool has_xla_reduce_window_rewrite_base_length() const;
  void clear_xla_reduce_window_rewrite_base_length() ;
  ::int64_t xla_reduce_window_rewrite_base_length() const;
  void set_xla_reduce_window_rewrite_base_length(::int64_t value);

  private:
  ::int64_t _internal_xla_reduce_window_rewrite_base_length() const;
  void _internal_set_xla_reduce_window_rewrite_base_length(::int64_t value);

  public:
  // optional int64 xla_cmd_buffer_trace_cache_size = 311;
  bool has_xla_cmd_buffer_trace_cache_size() const;
  void clear_xla_cmd_buffer_trace_cache_size() ;
  ::int64_t xla_cmd_buffer_trace_cache_size() const;
  void set_xla_cmd_buffer_trace_cache_size(::int64_t value);

  private:
  ::int64_t _internal_xla_cmd_buffer_trace_cache_size() const;
  void _internal_set_xla_cmd_buffer_trace_cache_size(::int64_t value);

  public:
  // optional int32 xla_cpu_prefer_vector_width = 308;
  bool has_xla_cpu_prefer_vector_width() const;
  void clear_xla_cpu_prefer_vector_width() ;
  ::int32_t xla_cpu_prefer_vector_width() const;
  void set_xla_cpu_prefer_vector_width(::int32_t value);

  private:
  ::int32_t _internal_xla_cpu_prefer_vector_width() const;
  void _internal_set_xla_cpu_prefer_vector_width(::int32_t value);

  public:
  // optional bool xla_enable_fast_math = 335;
  bool has_xla_enable_fast_math() const;
  void clear_xla_enable_fast_math() ;
  bool xla_enable_fast_math() const;
  void set_xla_enable_fast_math(bool value);

  private:
  bool _internal_xla_enable_fast_math() const;
  void _internal_set_xla_enable_fast_math(bool value);

  public:
  // optional bool xla_gpu_async_dot = 321;
  bool has_xla_gpu_async_dot() const;
  void clear_xla_gpu_async_dot() ;
  bool xla_gpu_async_dot() const;
  void set_xla_gpu_async_dot(bool value);

  private:
  bool _internal_xla_gpu_async_dot() const;
  void _internal_set_xla_gpu_async_dot(bool value);

  public:
  // optional bool xla_gpu_collect_cost_model_stats = 240;
  bool has_xla_gpu_collect_cost_model_stats() const;
  void clear_xla_gpu_collect_cost_model_stats() ;
  bool xla_gpu_collect_cost_model_stats() const;
  void set_xla_gpu_collect_cost_model_stats(bool value);

  private:
  bool _internal_xla_gpu_collect_cost_model_stats() const;
  void _internal_set_xla_gpu_collect_cost_model_stats(bool value);

  public:
  // optional bool xla_gpu_collectives_use_persistent_cliques = 354;
  bool has_xla_gpu_collectives_use_persistent_cliques() const;
  void clear_xla_gpu_collectives_use_persistent_cliques() ;
  bool xla_gpu_collectives_use_persistent_cliques() const;
  void set_xla_gpu_collectives_use_persistent_cliques(bool value);

  private:
  bool _internal_xla_gpu_collectives_use_persistent_cliques() const;
  void _internal_set_xla_gpu_collectives_use_persistent_cliques(bool value);

  public:
  // optional float xla_gpu_autotune_gemm_rtol = 316;
  bool has_xla_gpu_autotune_gemm_rtol() const;
  void clear_xla_gpu_autotune_gemm_rtol() ;
  float xla_gpu_autotune_gemm_rtol() const;
  void set_xla_gpu_autotune_gemm_rtol(float value);

  private:
  float _internal_xla_gpu_autotune_gemm_rtol() const;
  void _internal_set_xla_gpu_autotune_gemm_rtol(float value);

  public:
  // optional int32 xla_gpu_cudnn_gemm_max_plans = 318;
  bool has_xla_gpu_cudnn_gemm_max_plans() const;
  void clear_xla_gpu_cudnn_gemm_max_plans() ;
  ::int32_t xla_gpu_cudnn_gemm_max_plans() const;
  void set_xla_gpu_cudnn_gemm_max_plans(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_cudnn_gemm_max_plans() const;
  void _internal_set_xla_gpu_cudnn_gemm_max_plans(::int32_t value);

  public:
  // optional int32 xla_cpu_parallel_codegen_split_count = 323;
  bool has_xla_cpu_parallel_codegen_split_count() const;
  void clear_xla_cpu_parallel_codegen_split_count() ;
  ::int32_t xla_cpu_parallel_codegen_split_count() const;
  void set_xla_cpu_parallel_codegen_split_count(::int32_t value);

  private:
  ::int32_t _internal_xla_cpu_parallel_codegen_split_count() const;
  void _internal_set_xla_cpu_parallel_codegen_split_count(::int32_t value);

  public:
  // optional .xla.DebugOptions.AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode = 324;
  bool has_xla_gpu_experimental_autotune_cache_mode() const;
  void clear_xla_gpu_experimental_autotune_cache_mode() ;
  ::xla::DebugOptions_AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode() const;
  void set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value);

  private:
  ::xla::DebugOptions_AutotuneCacheMode _internal_xla_gpu_experimental_autotune_cache_mode() const;
  void _internal_set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value);

  public:
  // optional bool xla_syntax_sugar_async_ops = 315;
  bool has_xla_syntax_sugar_async_ops() const;
  void clear_xla_syntax_sugar_async_ops() ;
  bool xla_syntax_sugar_async_ops() const;
  void set_xla_syntax_sugar_async_ops(bool value);

  private:
  bool _internal_xla_syntax_sugar_async_ops() const;
  void _internal_set_xla_syntax_sugar_async_ops(bool value);

  public:
  // optional bool xla_enable_command_buffers_during_profiling = 317;
  bool has_xla_enable_command_buffers_during_profiling() const;
  void clear_xla_enable_command_buffers_during_profiling() ;
  bool xla_enable_command_buffers_during_profiling() const;
  void set_xla_enable_command_buffers_during_profiling(bool value);

  private:
  bool _internal_xla_enable_command_buffers_during_profiling() const;
  void _internal_set_xla_enable_command_buffers_during_profiling(bool value);

  public:
  // optional bool xla_ignore_channel_id = 330;
  bool has_xla_ignore_channel_id() const;
  void clear_xla_ignore_channel_id() ;
  bool xla_ignore_channel_id() const;
  void set_xla_ignore_channel_id(bool value);

  private:
  bool _internal_xla_ignore_channel_id() const;
  void _internal_set_xla_ignore_channel_id(bool value);

  public:
  // optional bool xla_pjrt_allow_auto_layout_in_hlo = 344;
  bool has_xla_pjrt_allow_auto_layout_in_hlo() const;
  void clear_xla_pjrt_allow_auto_layout_in_hlo() ;
  bool xla_pjrt_allow_auto_layout_in_hlo() const;
  void set_xla_pjrt_allow_auto_layout_in_hlo(bool value);

  private:
  bool _internal_xla_pjrt_allow_auto_layout_in_hlo() const;
  void _internal_set_xla_pjrt_allow_auto_layout_in_hlo(bool value);

  public:
  // optional int32 xla_gpu_executable_warn_stuck_timeout_seconds = 327;
  bool has_xla_gpu_executable_warn_stuck_timeout_seconds() const;
  void clear_xla_gpu_executable_warn_stuck_timeout_seconds() ;
  ::int32_t xla_gpu_executable_warn_stuck_timeout_seconds() const;
  void set_xla_gpu_executable_warn_stuck_timeout_seconds(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_executable_warn_stuck_timeout_seconds() const;
  void _internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(::int32_t value);

  public:
  // optional int32 xla_gpu_executable_terminate_timeout_seconds = 328;
  bool has_xla_gpu_executable_terminate_timeout_seconds() const;
  void clear_xla_gpu_executable_terminate_timeout_seconds() ;
  ::int32_t xla_gpu_executable_terminate_timeout_seconds() const;
  void set_xla_gpu_executable_terminate_timeout_seconds(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_executable_terminate_timeout_seconds() const;
  void _internal_set_xla_gpu_executable_terminate_timeout_seconds(::int32_t value);

  public:
  // optional int32 xla_gpu_dot_merger_threshold_mb = 331;
  bool has_xla_gpu_dot_merger_threshold_mb() const;
  void clear_xla_gpu_dot_merger_threshold_mb() ;
  ::int32_t xla_gpu_dot_merger_threshold_mb() const;
  void set_xla_gpu_dot_merger_threshold_mb(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_dot_merger_threshold_mb() const;
  void _internal_set_xla_gpu_dot_merger_threshold_mb(::int32_t value);

  public:
  // optional bool xla_gpu_experimental_stream_annotation = 342;
  bool has_xla_gpu_experimental_stream_annotation() const;
  void clear_xla_gpu_experimental_stream_annotation() ;
  bool xla_gpu_experimental_stream_annotation() const;
  void set_xla_gpu_experimental_stream_annotation(bool value);

  private:
  bool _internal_xla_gpu_experimental_stream_annotation() const;
  void _internal_set_xla_gpu_experimental_stream_annotation(bool value);

  public:
  // optional bool xla_gpu_experimental_use_autotuner_pass = 396;
  bool has_xla_gpu_experimental_use_autotuner_pass() const;
  void clear_xla_gpu_experimental_use_autotuner_pass() ;
  bool xla_gpu_experimental_use_autotuner_pass() const;
  void set_xla_gpu_experimental_use_autotuner_pass(bool value);

  private:
  bool _internal_xla_gpu_experimental_use_autotuner_pass() const;
  void _internal_set_xla_gpu_experimental_use_autotuner_pass(bool value);

  public:
  // optional bool xla_gpu_fail_ptx_compilation_on_register_spilling = 353;
  bool has_xla_gpu_fail_ptx_compilation_on_register_spilling() const;
  void clear_xla_gpu_fail_ptx_compilation_on_register_spilling() ;
  bool xla_gpu_fail_ptx_compilation_on_register_spilling() const;
  void set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value);

  private:
  bool _internal_xla_gpu_fail_ptx_compilation_on_register_spilling() const;
  void _internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value);

  public:
  // optional bool xla_gpu_filter_kernels_spilling_registers_on_autotuning = 250;
  bool has_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const;
  void clear_xla_gpu_filter_kernels_spilling_registers_on_autotuning() ;
  bool xla_gpu_filter_kernels_spilling_registers_on_autotuning() const;
  void set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value);

  private:
  bool _internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const;
  void _internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value);

  public:
  // optional int32 xla_gpu_experimental_parallel_collective_overlap_limit = 336;
  bool has_xla_gpu_experimental_parallel_collective_overlap_limit() const;
  void clear_xla_gpu_experimental_parallel_collective_overlap_limit() ;
  ::int32_t xla_gpu_experimental_parallel_collective_overlap_limit() const;
  void set_xla_gpu_experimental_parallel_collective_overlap_limit(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_experimental_parallel_collective_overlap_limit() const;
  void _internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(::int32_t value);

  public:
  // optional int64 xla_gpu_operand_bytes_threshold_for_windowed_einsum = 339;
  bool has_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const;
  void clear_xla_gpu_operand_bytes_threshold_for_windowed_einsum() ;
  ::int64_t xla_gpu_operand_bytes_threshold_for_windowed_einsum() const;
  void set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const;
  void _internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(::int64_t value);

  public:
  // optional .xla.DebugOptions.PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker = 341;
  bool has_xla_gpu_pgle_accuracy_checker() const;
  void clear_xla_gpu_pgle_accuracy_checker() ;
  ::xla::DebugOptions_PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker() const;
  void set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value);

  private:
  ::xla::DebugOptions_PGLEStrictnessLevel _internal_xla_gpu_pgle_accuracy_checker() const;
  void _internal_set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value);

  public:
  // optional bool xla_gpu_multi_streamed_windowed_einsum = 280;
  bool has_xla_gpu_multi_streamed_windowed_einsum() const;
  void clear_xla_gpu_multi_streamed_windowed_einsum() ;
  bool xla_gpu_multi_streamed_windowed_einsum() const;
  void set_xla_gpu_multi_streamed_windowed_einsum(bool value);

  private:
  bool _internal_xla_gpu_multi_streamed_windowed_einsum() const;
  void _internal_set_xla_gpu_multi_streamed_windowed_einsum(bool value);

  public:
  // optional bool xla_gpu_nccl_async_execution = 393;
  bool has_xla_gpu_nccl_async_execution() const;
  void clear_xla_gpu_nccl_async_execution() ;
  bool xla_gpu_nccl_async_execution() const;
  void set_xla_gpu_nccl_async_execution(bool value);

  private:
  bool _internal_xla_gpu_nccl_async_execution() const;
  void _internal_set_xla_gpu_nccl_async_execution(bool value);

  public:
  // optional bool xla_gpu_nccl_blocking_communicators = 390;
  bool has_xla_gpu_nccl_blocking_communicators() const;
  void clear_xla_gpu_nccl_blocking_communicators() ;
  bool xla_gpu_nccl_blocking_communicators() const;
  void set_xla_gpu_nccl_blocking_communicators(bool value);

  private:
  bool _internal_xla_gpu_nccl_blocking_communicators() const;
  void _internal_set_xla_gpu_nccl_blocking_communicators(bool value);

  public:
  // optional bool xla_gpu_nccl_terminate_on_error = 301;
  bool has_xla_gpu_nccl_terminate_on_error() const;
  void clear_xla_gpu_nccl_terminate_on_error() ;
  bool xla_gpu_nccl_terminate_on_error() const;
  void set_xla_gpu_nccl_terminate_on_error(bool value);

  private:
  bool _internal_xla_gpu_nccl_terminate_on_error() const;
  void _internal_set_xla_gpu_nccl_terminate_on_error(bool value);

  public:
  // optional .xla.DebugOptions.LibNvJitLinkMode xla_gpu_libnvjitlink_mode = 343;
  bool has_xla_gpu_libnvjitlink_mode() const;
  void clear_xla_gpu_libnvjitlink_mode() ;
  ::xla::DebugOptions_LibNvJitLinkMode xla_gpu_libnvjitlink_mode() const;
  void set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value);

  private:
  ::xla::DebugOptions_LibNvJitLinkMode _internal_xla_gpu_libnvjitlink_mode() const;
  void _internal_set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value);

  public:
  // optional .xla.DebugOptions.PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level = 351;
  bool has_xla_gpu_experimental_pipeline_parallelism_opt_level() const;
  void clear_xla_gpu_experimental_pipeline_parallelism_opt_level() ;
  ::xla::DebugOptions_PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level() const;
  void set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value);

  private:
  ::xla::DebugOptions_PipelineParallelismOptLevel _internal_xla_gpu_experimental_pipeline_parallelism_opt_level() const;
  void _internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value);

  public:
  // optional bool xla_cpu_generate_unique_c_style_kernel_entry_points = 372;
  bool has_xla_cpu_generate_unique_c_style_kernel_entry_points() const;
  void clear_xla_cpu_generate_unique_c_style_kernel_entry_points() ;
  bool xla_cpu_generate_unique_c_style_kernel_entry_points() const;
  void set_xla_cpu_generate_unique_c_style_kernel_entry_points(bool value);

  private:
  bool _internal_xla_cpu_generate_unique_c_style_kernel_entry_points() const;
  void _internal_set_xla_cpu_generate_unique_c_style_kernel_entry_points(bool value);

  public:
  // optional bool xla_cpu_use_fusion_emitters = 376;
  bool has_xla_cpu_use_fusion_emitters() const;
  void clear_xla_cpu_use_fusion_emitters() ;
  bool xla_cpu_use_fusion_emitters() const;
  void set_xla_cpu_use_fusion_emitters(bool value);

  private:
  bool _internal_xla_cpu_use_fusion_emitters() const;
  void _internal_set_xla_cpu_use_fusion_emitters(bool value);

  public:
  // optional bool xla_cpu_use_thunk_runtime = 298;
  bool has_xla_cpu_use_thunk_runtime() const;
  void clear_xla_cpu_use_thunk_runtime() ;
  bool xla_cpu_use_thunk_runtime() const;
  void set_xla_cpu_use_thunk_runtime(bool value);

  private:
  bool _internal_xla_cpu_use_thunk_runtime() const;
  void _internal_set_xla_cpu_use_thunk_runtime(bool value);

  public:
  // optional bool xla_cpu_use_xnnpack = 359;
  bool has_xla_cpu_use_xnnpack() const;
  void clear_xla_cpu_use_xnnpack() ;
  bool xla_cpu_use_xnnpack() const;
  void set_xla_cpu_use_xnnpack(bool value);

  private:
  bool _internal_xla_cpu_use_xnnpack() const;
  void _internal_set_xla_cpu_use_xnnpack(bool value);

  public:
  // optional bool xla_gpu_experimental_disable_binary_libraries = 329;
  bool has_xla_gpu_experimental_disable_binary_libraries() const;
  void clear_xla_gpu_experimental_disable_binary_libraries() ;
  bool xla_gpu_experimental_disable_binary_libraries() const;
  void set_xla_gpu_experimental_disable_binary_libraries(bool value);

  private:
  bool _internal_xla_gpu_experimental_disable_binary_libraries() const;
  void _internal_set_xla_gpu_experimental_disable_binary_libraries(bool value);

  public:
  // optional bool xla_gpu_experimental_dump_fdo_profiles = 338;
  bool has_xla_gpu_experimental_dump_fdo_profiles() const;
  void clear_xla_gpu_experimental_dump_fdo_profiles() ;
  bool xla_gpu_experimental_dump_fdo_profiles() const;
  void set_xla_gpu_experimental_dump_fdo_profiles(bool value);

  private:
  bool _internal_xla_gpu_experimental_dump_fdo_profiles() const;
  void _internal_set_xla_gpu_experimental_dump_fdo_profiles(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_alltoall_windowed_einsum = 360;
  bool has_xla_gpu_experimental_enable_alltoall_windowed_einsum() const;
  void clear_xla_gpu_experimental_enable_alltoall_windowed_einsum() ;
  bool xla_gpu_experimental_enable_alltoall_windowed_einsum() const;
  void set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_alltoall_windowed_einsum() const;
  void _internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_command_buffer_on_thunks = 394;
  bool has_xla_gpu_experimental_enable_command_buffer_on_thunks() const;
  void clear_xla_gpu_experimental_enable_command_buffer_on_thunks() ;
  bool xla_gpu_experimental_enable_command_buffer_on_thunks() const;
  void set_xla_gpu_experimental_enable_command_buffer_on_thunks(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_command_buffer_on_thunks() const;
  void _internal_set_xla_gpu_experimental_enable_command_buffer_on_thunks(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_subchannel_dequantisation_fusion = 368;
  bool has_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const;
  void clear_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() ;
  bool xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const;
  void set_xla_gpu_experimental_enable_subchannel_dequantisation_fusion(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const;
  void _internal_set_xla_gpu_experimental_enable_subchannel_dequantisation_fusion(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_triton_heroless_priority_fusion = 340;
  bool has_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const;
  void clear_xla_gpu_experimental_enable_triton_heroless_priority_fusion() ;
  bool xla_gpu_experimental_enable_triton_heroless_priority_fusion() const;
  void set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const;
  void _internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_triton_tma = 355;
  bool has_xla_gpu_experimental_enable_triton_tma() const;
  void clear_xla_gpu_experimental_enable_triton_tma() ;
  bool xla_gpu_experimental_enable_triton_tma() const;
  void set_xla_gpu_experimental_enable_triton_tma(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_triton_tma() const;
  void _internal_set_xla_gpu_experimental_enable_triton_tma(bool value);

  public:
  // optional bool xla_gpu_experimental_pack_dot_operands_along_k_dimension = 362;
  bool has_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const;
  void clear_xla_gpu_experimental_pack_dot_operands_along_k_dimension() ;
  bool xla_gpu_experimental_pack_dot_operands_along_k_dimension() const;
  void set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value);

  private:
  bool _internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const;
  void _internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value);

  public:
  // optional bool xla_gpu_unsupported_enable_all_reduce_decomposer = 384;
  bool has_xla_gpu_unsupported_enable_all_reduce_decomposer() const;
  void clear_xla_gpu_unsupported_enable_all_reduce_decomposer() ;
  bool xla_gpu_unsupported_enable_all_reduce_decomposer() const;
  void set_xla_gpu_unsupported_enable_all_reduce_decomposer(bool value);

  private:
  bool _internal_xla_gpu_unsupported_enable_all_reduce_decomposer() const;
  void _internal_set_xla_gpu_unsupported_enable_all_reduce_decomposer(bool value);

  public:
  // optional bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer = 350;
  bool has_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const;
  void clear_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() ;
  bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const;
  void set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value);

  private:
  bool _internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const;
  void _internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value);

  public:
  // optional bool xla_gpu_unsupported_enable_triton_gemm = 322;
  bool has_xla_gpu_unsupported_enable_triton_gemm() const;
  void clear_xla_gpu_unsupported_enable_triton_gemm() ;
  bool xla_gpu_unsupported_enable_triton_gemm() const;
  void set_xla_gpu_unsupported_enable_triton_gemm(bool value);

  private:
  bool _internal_xla_gpu_unsupported_enable_triton_gemm() const;
  void _internal_set_xla_gpu_unsupported_enable_triton_gemm(bool value);

  public:
  // optional bool xla_gpu_unsupported_enable_triton_multi_output_fusion = 382;
  bool has_xla_gpu_unsupported_enable_triton_multi_output_fusion() const;
  void clear_xla_gpu_unsupported_enable_triton_multi_output_fusion() ;
  bool xla_gpu_unsupported_enable_triton_multi_output_fusion() const;
  void set_xla_gpu_unsupported_enable_triton_multi_output_fusion(bool value);

  private:
  bool _internal_xla_gpu_unsupported_enable_triton_multi_output_fusion() const;
  void _internal_set_xla_gpu_unsupported_enable_triton_multi_output_fusion(bool value);

  public:
  // optional bool xla_gpu_unsupported_use_all_reduce_one_shot_kernel = 387;
  bool has_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const;
  void clear_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() ;
  bool xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const;
  void set_xla_gpu_unsupported_use_all_reduce_one_shot_kernel(bool value);

  private:
  bool _internal_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const;
  void _internal_set_xla_gpu_unsupported_use_all_reduce_one_shot_kernel(bool value);

  public:
  // optional bool xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel = 375;
  bool has_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const;
  void clear_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() ;
  bool xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const;
  void set_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel(bool value);

  private:
  bool _internal_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const;
  void _internal_set_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel(bool value);

  public:
  // optional bool xla_gpu_use_inprocess_lld = 389;
  bool has_xla_gpu_use_inprocess_lld() const;
  void clear_xla_gpu_use_inprocess_lld() ;
  bool xla_gpu_use_inprocess_lld() const;
  void set_xla_gpu_use_inprocess_lld(bool value);

  private:
  bool _internal_xla_gpu_use_inprocess_lld() const;
  void _internal_set_xla_gpu_use_inprocess_lld(bool value);

  public:
  // optional bool xla_gpu_use_memcpy_local_p2p = 287;
  bool has_xla_gpu_use_memcpy_local_p2p() const;
  void clear_xla_gpu_use_memcpy_local_p2p() ;
  bool xla_gpu_use_memcpy_local_p2p() const;
  void set_xla_gpu_use_memcpy_local_p2p(bool value);

  private:
  bool _internal_xla_gpu_use_memcpy_local_p2p() const;
  void _internal_set_xla_gpu_use_memcpy_local_p2p(bool value);

  public:
  // optional .xla.DebugOptions.XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode = 365;
  bool has_xla_cpu_experimental_xnn_graph_fusion_mode() const;
  void clear_xla_cpu_experimental_xnn_graph_fusion_mode() ;
  ::xla::DebugOptions_XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode() const;
  void set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value);

  private:
  ::xla::DebugOptions_XnnGraphFusionMode _internal_xla_cpu_experimental_xnn_graph_fusion_mode() const;
  void _internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value);

  public:
  // optional bool xla_gpu_experimental_enable_fusion_block_level_rewriter = 334;
  bool has_xla_gpu_experimental_enable_fusion_block_level_rewriter() const;
  void clear_xla_gpu_experimental_enable_fusion_block_level_rewriter() ;
  bool xla_gpu_experimental_enable_fusion_block_level_rewriter() const;
  void set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_fusion_block_level_rewriter() const;
  void _internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_heuristic_collective_combining = 366;
  bool has_xla_gpu_experimental_enable_heuristic_collective_combining() const;
  void clear_xla_gpu_experimental_enable_heuristic_collective_combining() ;
  bool xla_gpu_experimental_enable_heuristic_collective_combining() const;
  void set_xla_gpu_experimental_enable_heuristic_collective_combining(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_heuristic_collective_combining() const;
  void _internal_set_xla_gpu_experimental_enable_heuristic_collective_combining(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_nvshmem = 388;
  bool has_xla_gpu_experimental_enable_nvshmem() const;
  void clear_xla_gpu_experimental_enable_nvshmem() ;
  bool xla_gpu_experimental_enable_nvshmem() const;
  void set_xla_gpu_experimental_enable_nvshmem(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_nvshmem() const;
  void _internal_set_xla_gpu_experimental_enable_nvshmem(bool value);

  public:
  // optional bool xla_gpu_experimental_enable_split_k_rewrite = 386;
  bool has_xla_gpu_experimental_enable_split_k_rewrite() const;
  void clear_xla_gpu_experimental_enable_split_k_rewrite() ;
  bool xla_gpu_experimental_enable_split_k_rewrite() const;
  void set_xla_gpu_experimental_enable_split_k_rewrite(bool value);

  private:
  bool _internal_xla_gpu_experimental_enable_split_k_rewrite() const;
  void _internal_set_xla_gpu_experimental_enable_split_k_rewrite(bool value);

  public:
  // optional bool xla_hlo_pass_fix_detect_cycles = 370;
  bool has_xla_hlo_pass_fix_detect_cycles() const;
  void clear_xla_hlo_pass_fix_detect_cycles() ;
  bool xla_hlo_pass_fix_detect_cycles() const;
  void set_xla_hlo_pass_fix_detect_cycles(bool value);

  private:
  bool _internal_xla_hlo_pass_fix_detect_cycles() const;
  void _internal_set_xla_hlo_pass_fix_detect_cycles(bool value);

  public:
  // optional bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations = 363;
  bool has_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const;
  void clear_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() ;
  bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const;
  void set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value);

  private:
  bool _internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const;
  void _internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value);

  public:
  // optional bool xla_unsupported_crash_on_hlo_pass_noop_change = 379;
  bool has_xla_unsupported_crash_on_hlo_pass_noop_change() const;
  void clear_xla_unsupported_crash_on_hlo_pass_noop_change() ;
  bool xla_unsupported_crash_on_hlo_pass_noop_change() const;
  void set_xla_unsupported_crash_on_hlo_pass_noop_change(bool value);

  private:
  bool _internal_xla_unsupported_crash_on_hlo_pass_noop_change() const;
  void _internal_set_xla_unsupported_crash_on_hlo_pass_noop_change(bool value);

  public:
  // optional bool xla_unsupported_crash_on_hlo_pass_silent_hlo_change = 380;
  bool has_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const;
  void clear_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() ;
  bool xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const;
  void set_xla_unsupported_crash_on_hlo_pass_silent_hlo_change(bool value);

  private:
  bool _internal_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const;
  void _internal_set_xla_unsupported_crash_on_hlo_pass_silent_hlo_change(bool value);

  public:
  // optional int64 xla_gpu_experimental_collective_cse_distance_threshold = 374;
  bool has_xla_gpu_experimental_collective_cse_distance_threshold() const;
  void clear_xla_gpu_experimental_collective_cse_distance_threshold() ;
  ::int64_t xla_gpu_experimental_collective_cse_distance_threshold() const;
  void set_xla_gpu_experimental_collective_cse_distance_threshold(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_experimental_collective_cse_distance_threshold() const;
  void _internal_set_xla_gpu_experimental_collective_cse_distance_threshold(::int64_t value);

  public:
  // optional int64 xla_gpu_collective_permute_combine_threshold_bytes = 378;
  bool has_xla_gpu_collective_permute_combine_threshold_bytes() const;
  void clear_xla_gpu_collective_permute_combine_threshold_bytes() ;
  ::int64_t xla_gpu_collective_permute_combine_threshold_bytes() const;
  void set_xla_gpu_collective_permute_combine_threshold_bytes(::int64_t value);

  private:
  ::int64_t _internal_xla_gpu_collective_permute_combine_threshold_bytes() const;
  void _internal_set_xla_gpu_collective_permute_combine_threshold_bytes(::int64_t value);

  public:
  // optional bool xla_test_add_command_buffer_mode = 373;
  bool has_xla_test_add_command_buffer_mode() const;
  void clear_xla_test_add_command_buffer_mode() ;
  bool xla_test_add_command_buffer_mode() const;
  void set_xla_test_add_command_buffer_mode(bool value);

  private:
  bool _internal_xla_test_add_command_buffer_mode() const;
  void _internal_set_xla_test_add_command_buffer_mode(bool value);

  public:
  // optional bool xla_early_exit_with_layouts = 397;
  bool has_xla_early_exit_with_layouts() const;
  void clear_xla_early_exit_with_layouts() ;
  bool xla_early_exit_with_layouts() const;
  void set_xla_early_exit_with_layouts(bool value);

  private:
  bool _internal_xla_early_exit_with_layouts() const;
  void _internal_set_xla_early_exit_with_layouts(bool value);

  public:
  // optional int32 xla_gpu_first_collective_call_warn_stuck_timeout_seconds = 391;
  bool has_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const;
  void clear_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() ;
  ::int32_t xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const;
  void set_xla_gpu_first_collective_call_warn_stuck_timeout_seconds(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const;
  void _internal_set_xla_gpu_first_collective_call_warn_stuck_timeout_seconds(::int32_t value);

  public:
  // optional int32 xla_gpu_first_collective_call_terminate_timeout_seconds = 392;
  bool has_xla_gpu_first_collective_call_terminate_timeout_seconds() const;
  void clear_xla_gpu_first_collective_call_terminate_timeout_seconds() ;
  ::int32_t xla_gpu_first_collective_call_terminate_timeout_seconds() const;
  void set_xla_gpu_first_collective_call_terminate_timeout_seconds(::int32_t value);

  private:
  ::int32_t _internal_xla_gpu_first_collective_call_terminate_timeout_seconds() const;
  void _internal_set_xla_gpu_first_collective_call_terminate_timeout_seconds(::int32_t value);

  public:
  // optional int32 xla_cpu_emitter_verification_level = 395;
  bool has_xla_cpu_emitter_verification_level() const;
  void clear_xla_cpu_emitter_verification_level() ;
  ::int32_t xla_cpu_emitter_verification_level() const;
  void set_xla_cpu_emitter_verification_level(::int32_t value);

  private:
  ::int32_t _internal_xla_cpu_emitter_verification_level() const;
  void _internal_set_xla_cpu_emitter_verification_level(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:xla.DebugOptions)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 239, 2,
      978, 56>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const DebugOptions& from_msg);
    ::google::protobuf::internal::HasBits<8> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<std::string> xla_disable_hlo_passes_;
    ::google::protobuf::RepeatedPtrField<std::string> xla_enable_hlo_passes_only_;
    ::google::protobuf::RepeatedPtrField<std::string> xla_gpu_ptx_file_;
    ::google::protobuf::RepeatedPtrField<std::string> xla_gpu_llvm_ir_file_;
    ::google::protobuf::RepeatedField<int> xla_gpu_enable_command_buffer_;
    mutable ::google::protobuf::internal::CachedSize _xla_gpu_enable_command_buffer_cached_byte_size_;
    ::google::protobuf::RepeatedField<int> xla_gpu_disable_async_collectives_;
    mutable ::google::protobuf::internal::CachedSize _xla_gpu_disable_async_collectives_cached_byte_size_;
    ::google::protobuf::RepeatedPtrField<std::string> legacy_command_buffer_custom_call_targets_;
    ::google::protobuf::internal::MapField<DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse, std::string, std::string,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>
        xla_gpu_analytical_latency_estimator_options_;
    ::google::protobuf::RepeatedField<int> xla_gpu_unsupported_generic_triton_emitter_features_;
    mutable ::google::protobuf::internal::CachedSize _xla_gpu_unsupported_generic_triton_emitter_features_cached_byte_size_;
    ::google::protobuf::internal::MapField<DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse, std::string, std::string,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>
        xla_backend_extra_options_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_cuda_data_dir_;
    ::google::protobuf::internal::ArenaStringPtr xla_dump_to_;
    ::google::protobuf::internal::ArenaStringPtr xla_dump_hlo_module_re_;
    ::google::protobuf::internal::ArenaStringPtr xla_dump_hlo_pass_re_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_algorithm_denylist_path_;
    ::google::protobuf::internal::ArenaStringPtr xla_dump_hlo_pipeline_re_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_pgle_profile_file_or_directory_path_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_dump_autotune_results_to_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_load_autotune_results_from_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_target_config_filename_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_enable_custom_fusions_re_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_dump_autotune_logs_to_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_override_gemm_autotuner_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_kernel_cache_file_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_per_fusion_autotune_cache_dir_;
    ::google::protobuf::internal::ArenaStringPtr xla_cpu_max_isa_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_experimental_collective_perf_table_path_;
    ::google::protobuf::internal::ArenaStringPtr xla_gpu_experimental_matmul_perf_table_path_;
    ::int32_t xla_backend_optimization_level_;
    bool xla_disable_all_hlo_passes_;
    bool xla_embed_ir_in_executable_;
    bool xla_eliminate_hlo_implicit_broadcast_;
    bool xla_cpu_multi_thread_eigen_;
    bool xla_llvm_enable_alias_scope_metadata_;
    bool xla_llvm_enable_noalias_metadata_;
    bool xla_llvm_enable_invariant_load_metadata_;
    bool xla_llvm_disable_expensive_passes_;
    bool xla_test_all_output_layouts_;
    bool xla_test_all_input_layouts_;
    bool xla_hlo_graph_sharding_color_;
    bool xla_cpu_use_onednn_;
    ::int32_t xla_force_host_platform_device_count_;
    int xla_step_marker_location_;
    bool xla_dump_hlo_as_text_;
    bool xla_dump_hlo_as_proto_;
    bool xla_dump_hlo_as_dot_;
    bool xla_dump_hlo_as_url_;
    bool xla_gpu_use_runtime_fusion_;
    bool xla_gpu_verify_triton_fusion_numerics_;
    bool xla_hlo_graph_addresses_;
    bool xla_hlo_profile_;
    ::int32_t xla_gpu_autotune_level_;
    bool xla_cpu_fast_math_honor_division_;
    bool xla_cpu_fast_math_honor_functions_;
    bool xla_cpu_fast_math_honor_infs_;
    bool xla_cpu_fast_math_honor_nans_;
    bool xla_dump_hlo_as_html_;
    bool xla_dump_fusion_visualization_;
    bool xla_dump_hlo_snapshots_;
    bool xla_dump_include_timestamp_;
    ::int32_t xla_dump_max_hlo_modules_;
    ::int32_t xla_multiheap_size_constraint_per_heap_;
    bool xla_gpu_force_conv_nchw_;
    bool xla_gpu_force_conv_nhwc_;
    bool xla_gpu_ftz_;
    bool xla_gpu_fused_attention_use_cudnn_rng_;
    ::int32_t xla_gpu_force_compilation_parallelism_;
    ::int32_t xla_gpu_all_reduce_blueconnect_num_devices_per_host_;
    ::int64_t xla_gpu_all_reduce_combine_threshold_bytes_;
    bool xla_dump_module_metadata_;
    bool xla_dump_compress_protos_;
    bool xla_dump_hlo_as_long_text_;
    bool xla_dump_enable_mlir_pretty_form_;
    int xla_gpu_shape_checks_;
    ::int64_t xla_gpu_nccl_termination_timeout_seconds_;
    ::int64_t xla_gpu_redzone_scratch_max_megabytes_;
    bool xla_gpu_enable_custom_fusions_;
    bool xla_gpu_enable_dynamic_slice_fusion_;
    bool xla_gpu_enable_fast_min_max_;
    bool xla_gpu_enable_highest_priority_async_stream_;
    bool xla_allow_excess_precision_;
    bool xla_hlo_evaluator_use_fast_path_;
    bool xla_allow_scalar_index_dynamic_ops_;
    bool xla_flags_reset_;
    bool xla_gpu_copy_insertion_use_region_analysis_;
    bool xla_gpu_crash_on_verification_failures_;
    bool xla_gpu_cublas_fallback_;
    bool xla_gpu_deterministic_ops_;
    int xla_partitioning_algorithm_;
    bool xla_dump_full_hlo_config_;
    bool xla_tpu_detect_nan_;
    bool xla_tpu_detect_inf_;
    bool xla_cpu_enable_xprof_traceme_;
    ::int32_t xla_gpu_collective_inflation_factor_;
    bool xla_cpu_use_acl_;
    bool xla_cpu_strict_dot_conv_math_;
    bool xla_dump_latency_hiding_schedule_;
    bool xla_dump_large_constants_;
    ::int32_t xla_gpu_graph_min_graph_size_;
    ::int64_t xla_gpu_all_gather_combine_threshold_bytes_;
    bool xla_gpu_disable_gpuasm_optimizations_;
    bool xla_gpu_dump_autotuned_gemm_fusions_;
    bool xla_gpu_dump_hlo_unoptimized_snapshots_;
    bool xla_gpu_dump_llvmir_;
    bool xla_gpu_enable_shared_constants_;
    bool xla_gpu_enable_split_k_autotuning_;
    bool xla_gpu_enable_triton_gemm_;
    bool xla_gpu_enable_triton_hopper_;
    ::int64_t xla_gpu_reduce_scatter_combine_threshold_bytes_;
    bool xla_gpu_enable_cub_radix_sort_;
    bool xla_gpu_enable_cublaslt_;
    bool xla_gpu_enable_cudnn_int8x32_convolution_reordering_;
    bool xla_gpu_enable_cudnn_layer_norm_;
    bool xla_cpu_copy_insertion_use_region_analysis_;
    bool xla_cpu_enable_concurrency_optimized_scheduler_;
    bool xla_cpu_enable_fast_math_;
    bool xla_cpu_enable_fast_min_max_;
    ::int32_t xla_gpu_auto_spmd_partitioning_memory_budget_gb_;
    float xla_gpu_auto_spmd_partitioning_memory_budget_ratio_;
    ::int64_t xla_gpu_redzone_padding_bytes_;
    bool xla_gpu_enable_pipelined_all_reduce_;
    bool xla_gpu_enable_pipelined_collectives_;
    bool xla_gpu_enable_pipelined_p2p_;
    bool xla_gpu_enable_pipelined_reduce_scatter_;
    bool xla_detailed_logging_;
    bool xla_enable_dumping_;
    bool xla_llvm_force_inline_before_split_;
    bool xla_dump_disable_metadata_;
    ::int64_t xla_gpu_collective_permute_decomposer_threshold_;
    bool xla_gpu_enable_while_loop_double_buffering_;
    bool xla_gpu_enable_while_loop_reduce_scatter_code_motion_;
    bool xla_gpu_exclude_nondeterministic_ops_;
    bool xla_gpu_exhaustive_tiling_search_;
    bool xla_gpu_temp_buffer_use_separate_color_;
    bool xla_gpu_triton_gemm_any_;
    bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_;
    bool xla_gpu_unsupported_annotate_with_emitter_loc_;
    ::int64_t xla_debug_buffer_assignment_show_max_;
    bool xla_gpu_enable_nccl_clique_optimization_;
    bool xla_gpu_enable_nccl_comm_splitting_;
    bool xla_gpu_enable_nccl_user_buffers_;
    bool xla_gpu_enable_pipelined_all_gather_;
    bool xla_gpu_enable_host_memory_offloading_;
    bool xla_gpu_enable_latency_hiding_scheduler_;
    bool xla_gpu_enable_libnvptxcompiler_;
    bool xla_gpu_enable_llvm_module_compilation_parallelism_;
    ::int32_t xla_gpu_llvm_verification_level_;
    ::int32_t xla_gpu_memory_limit_slop_factor_;
    ::int64_t xla_gpu_threshold_for_windowed_einsum_mib_;
    bool xla_gpu_enable_reassociation_for_converted_ar_;
    bool xla_gpu_enable_reduce_scatter_combine_by_dim_;
    bool xla_gpu_enable_reduction_epilogue_fusion_;
    bool xla_gpu_enable_scatter_determinism_expander_;
    bool xla_gpu_require_complete_aot_autotune_results_;
    bool xla_gpu_require_exclusive_lock_;
    bool xla_gpu_shard_autotuning_;
    bool xla_gpu_strict_conv_algorithm_picker_;
    ::int64_t xla_gpu_nccl_collective_max_nchannels_;
    ::int64_t xla_gpu_nccl_p2p_max_nchannels_;
    ::int64_t xla_gpu_nccl_init_max_rank_per_root_ratio_;
    ::int64_t xla_gpu_gemm_rewrite_size_threshold_;
    ::int64_t xla_gpu_autotune_max_solutions_;
    ::int32_t xla_gpu_cudnn_gemm_fusion_level_;
    bool xla_gpu_generate_debug_info_;
    bool xla_gpu_generate_line_info_;
    bool xla_gpu_graph_enable_concurrent_region_;
    bool xla_gpu_mock_custom_calls_;
    bool xla_gpu_enable_all_gather_combine_by_dim_;
    bool xla_gpu_enable_analytical_latency_estimator_;
    bool xla_gpu_enable_analytical_sol_latency_estimator_;
    bool xla_gpu_enable_approx_costly_collectives_;
    int xla_gpu_enable_while_loop_unrolling_;
    ::int64_t xla_reduce_window_rewrite_base_length_;
    ::int64_t xla_cmd_buffer_trace_cache_size_;
    ::int32_t xla_cpu_prefer_vector_width_;
    bool xla_enable_fast_math_;
    bool xla_gpu_async_dot_;
    bool xla_gpu_collect_cost_model_stats_;
    bool xla_gpu_collectives_use_persistent_cliques_;
    float xla_gpu_autotune_gemm_rtol_;
    ::int32_t xla_gpu_cudnn_gemm_max_plans_;
    ::int32_t xla_cpu_parallel_codegen_split_count_;
    int xla_gpu_experimental_autotune_cache_mode_;
    bool xla_syntax_sugar_async_ops_;
    bool xla_enable_command_buffers_during_profiling_;
    bool xla_ignore_channel_id_;
    bool xla_pjrt_allow_auto_layout_in_hlo_;
    ::int32_t xla_gpu_executable_warn_stuck_timeout_seconds_;
    ::int32_t xla_gpu_executable_terminate_timeout_seconds_;
    ::int32_t xla_gpu_dot_merger_threshold_mb_;
    bool xla_gpu_experimental_stream_annotation_;
    bool xla_gpu_experimental_use_autotuner_pass_;
    bool xla_gpu_fail_ptx_compilation_on_register_spilling_;
    bool xla_gpu_filter_kernels_spilling_registers_on_autotuning_;
    ::int32_t xla_gpu_experimental_parallel_collective_overlap_limit_;
    ::int64_t xla_gpu_operand_bytes_threshold_for_windowed_einsum_;
    int xla_gpu_pgle_accuracy_checker_;
    bool xla_gpu_multi_streamed_windowed_einsum_;
    bool xla_gpu_nccl_async_execution_;
    bool xla_gpu_nccl_blocking_communicators_;
    bool xla_gpu_nccl_terminate_on_error_;
    int xla_gpu_libnvjitlink_mode_;
    int xla_gpu_experimental_pipeline_parallelism_opt_level_;
    bool xla_cpu_generate_unique_c_style_kernel_entry_points_;
    bool xla_cpu_use_fusion_emitters_;
    bool xla_cpu_use_thunk_runtime_;
    bool xla_cpu_use_xnnpack_;
    bool xla_gpu_experimental_disable_binary_libraries_;
    bool xla_gpu_experimental_dump_fdo_profiles_;
    bool xla_gpu_experimental_enable_alltoall_windowed_einsum_;
    bool xla_gpu_experimental_enable_command_buffer_on_thunks_;
    bool xla_gpu_experimental_enable_subchannel_dequantisation_fusion_;
    bool xla_gpu_experimental_enable_triton_heroless_priority_fusion_;
    bool xla_gpu_experimental_enable_triton_tma_;
    bool xla_gpu_experimental_pack_dot_operands_along_k_dimension_;
    bool xla_gpu_unsupported_enable_all_reduce_decomposer_;
    bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_;
    bool xla_gpu_unsupported_enable_triton_gemm_;
    bool xla_gpu_unsupported_enable_triton_multi_output_fusion_;
    bool xla_gpu_unsupported_use_all_reduce_one_shot_kernel_;
    bool xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel_;
    bool xla_gpu_use_inprocess_lld_;
    bool xla_gpu_use_memcpy_local_p2p_;
    int xla_cpu_experimental_xnn_graph_fusion_mode_;
    bool xla_gpu_experimental_enable_fusion_block_level_rewriter_;
    bool xla_gpu_experimental_enable_heuristic_collective_combining_;
    bool xla_gpu_experimental_enable_nvshmem_;
    bool xla_gpu_experimental_enable_split_k_rewrite_;
    bool xla_hlo_pass_fix_detect_cycles_;
    bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations_;
    bool xla_unsupported_crash_on_hlo_pass_noop_change_;
    bool xla_unsupported_crash_on_hlo_pass_silent_hlo_change_;
    ::int64_t xla_gpu_experimental_collective_cse_distance_threshold_;
    ::int64_t xla_gpu_collective_permute_combine_threshold_bytes_;
    bool xla_test_add_command_buffer_mode_;
    bool xla_early_exit_with_layouts_;
    ::int32_t xla_gpu_first_collective_call_warn_stuck_timeout_seconds_;
    ::int32_t xla_gpu_first_collective_call_terminate_timeout_seconds_;
    ::int32_t xla_cpu_emitter_verification_level_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT CompilationEnvironmentsProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.CompilationEnvironmentsProto) */ {
 public:
  inline CompilationEnvironmentsProto() : CompilationEnvironmentsProto(nullptr) {}
  ~CompilationEnvironmentsProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR CompilationEnvironmentsProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline CompilationEnvironmentsProto(const CompilationEnvironmentsProto& from) : CompilationEnvironmentsProto(nullptr, from) {}
  inline CompilationEnvironmentsProto(CompilationEnvironmentsProto&& from) noexcept
      : CompilationEnvironmentsProto(nullptr, std::move(from)) {}
  inline CompilationEnvironmentsProto& operator=(const CompilationEnvironmentsProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompilationEnvironmentsProto& operator=(CompilationEnvironmentsProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompilationEnvironmentsProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompilationEnvironmentsProto* internal_default_instance() {
    return reinterpret_cast<const CompilationEnvironmentsProto*>(
        &_CompilationEnvironmentsProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(CompilationEnvironmentsProto& a, CompilationEnvironmentsProto& b) { a.Swap(&b); }
  inline void Swap(CompilationEnvironmentsProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompilationEnvironmentsProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CompilationEnvironmentsProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<CompilationEnvironmentsProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CompilationEnvironmentsProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const CompilationEnvironmentsProto& from) { CompilationEnvironmentsProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CompilationEnvironmentsProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.CompilationEnvironmentsProto"; }

 protected:
  explicit CompilationEnvironmentsProto(::google::protobuf::Arena* arena);
  CompilationEnvironmentsProto(::google::protobuf::Arena* arena, const CompilationEnvironmentsProto& from);
  CompilationEnvironmentsProto(::google::protobuf::Arena* arena, CompilationEnvironmentsProto&& from) noexcept
      : CompilationEnvironmentsProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kEnvironmentsFieldNumber = 1,
  };
  // repeated .google.protobuf.Any environments = 1;
  int environments_size() const;
  private:
  int _internal_environments_size() const;

  public:
  void clear_environments() ;
  ::google::protobuf::Any* mutable_environments(int index);
  ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>* mutable_environments();

  private:
  const ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>& _internal_environments() const;
  ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>* _internal_mutable_environments();
  public:
  const ::google::protobuf::Any& environments(int index) const;
  ::google::protobuf::Any* add_environments();
  const ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>& environments() const;
  // @@protoc_insertion_point(class_scope:xla.CompilationEnvironmentsProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const CompilationEnvironmentsProto& from_msg);
    ::google::protobuf::RepeatedPtrField< ::google::protobuf::Any > environments_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ExecutionOptions final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ExecutionOptions) */ {
 public:
  inline ExecutionOptions() : ExecutionOptions(nullptr) {}
  ~ExecutionOptions() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ExecutionOptions(
      ::google::protobuf::internal::ConstantInitialized);

  inline ExecutionOptions(const ExecutionOptions& from) : ExecutionOptions(nullptr, from) {}
  inline ExecutionOptions(ExecutionOptions&& from) noexcept
      : ExecutionOptions(nullptr, std::move(from)) {}
  inline ExecutionOptions& operator=(const ExecutionOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExecutionOptions& operator=(ExecutionOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ExecutionOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExecutionOptions* internal_default_instance() {
    return reinterpret_cast<const ExecutionOptions*>(
        &_ExecutionOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(ExecutionOptions& a, ExecutionOptions& b) { a.Swap(&b); }
  inline void Swap(ExecutionOptions* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExecutionOptions* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ExecutionOptions* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ExecutionOptions>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ExecutionOptions& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ExecutionOptions& from) { ExecutionOptions::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ExecutionOptions* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ExecutionOptions"; }

 protected:
  explicit ExecutionOptions(::google::protobuf::Arena* arena);
  ExecutionOptions(::google::protobuf::Arena* arena, const ExecutionOptions& from);
  ExecutionOptions(::google::protobuf::Arena* arena, ExecutionOptions&& from) noexcept
      : ExecutionOptions(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using EffortLevel = ExecutionOptions_EffortLevel;
  static constexpr EffortLevel EFFORT_UNKNOWN = ExecutionOptions_EffortLevel_EFFORT_UNKNOWN;
  static constexpr EffortLevel EFFORT_O0 = ExecutionOptions_EffortLevel_EFFORT_O0;
  static constexpr EffortLevel EFFORT_O1 = ExecutionOptions_EffortLevel_EFFORT_O1;
  static constexpr EffortLevel EFFORT_O2 = ExecutionOptions_EffortLevel_EFFORT_O2;
  static constexpr EffortLevel EFFORT_O3 = ExecutionOptions_EffortLevel_EFFORT_O3;
  static inline bool EffortLevel_IsValid(int value) {
    return ExecutionOptions_EffortLevel_IsValid(value);
  }
  static constexpr EffortLevel EffortLevel_MIN = ExecutionOptions_EffortLevel_EffortLevel_MIN;
  static constexpr EffortLevel EffortLevel_MAX = ExecutionOptions_EffortLevel_EffortLevel_MAX;
  static constexpr int EffortLevel_ARRAYSIZE = ExecutionOptions_EffortLevel_EffortLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* EffortLevel_descriptor() {
    return ExecutionOptions_EffortLevel_descriptor();
  }
  template <typename T>
  static inline const std::string& EffortLevel_Name(T value) {
    return ExecutionOptions_EffortLevel_Name(value);
  }
  static inline bool EffortLevel_Parse(absl::string_view name, EffortLevel* value) {
    return ExecutionOptions_EffortLevel_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceHandlesFieldNumber = 5,
    kAllowSpmdShardingPropagationToOutputFieldNumber = 14,
    kAutoSpmdPartitioningMeshShapeFieldNumber = 16,
    kAutoSpmdPartitioningMeshIdsFieldNumber = 17,
    kParamRequiresBroadcastViaCollectivesFieldNumber = 18,
    kShardableValueUpdatePairsFieldNumber = 20,
    kAllowSpmdShardingPropagationToParametersFieldNumber = 23,
    kFdoProfileFieldNumber = 21,
    kShapeWithOutputLayoutFieldNumber = 2,
    kDebugOptionsFieldNumber = 4,
    kDeviceAssignmentFieldNumber = 7,
    kSeedFieldNumber = 3,
    kNumReplicasFieldNumber = 6,
    kNumPartitionsFieldNumber = 9,
    kLaunchIdFieldNumber = 10,
    kAliasPassthroughParamsFieldNumber = 8,
    kUseSpmdPartitioningFieldNumber = 11,
    kUseAutoSpmdPartitioningFieldNumber = 15,
    kDeduplicateHloFieldNumber = 12,
    kDeviceMemorySizeFieldNumber = 22,
    kAllowSeparateShardingProgramsFieldNumber = 19,
    kUseShardyPartitionerFieldNumber = 24,
    kExecTimeOptimizationEffortFieldNumber = 25,
    kMemoryFittingEffortFieldNumber = 26,
    kOptimizationLevelFieldNumber = 27,
    kMemoryFittingLevelFieldNumber = 28,
  };
  // repeated .xla.DeviceHandle device_handles = 5;
  int device_handles_size() const;
  private:
  int _internal_device_handles_size() const;

  public:
  void clear_device_handles() ;
  ::xla::DeviceHandle* mutable_device_handles(int index);
  ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>* mutable_device_handles();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>& _internal_device_handles() const;
  ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>* _internal_mutable_device_handles();
  public:
  const ::xla::DeviceHandle& device_handles(int index) const;
  ::xla::DeviceHandle* add_device_handles();
  const ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>& device_handles() const;
  // repeated bool allow_spmd_sharding_propagation_to_output = 14;
  int allow_spmd_sharding_propagation_to_output_size() const;
  private:
  int _internal_allow_spmd_sharding_propagation_to_output_size() const;

  public:
  void clear_allow_spmd_sharding_propagation_to_output() ;
  bool allow_spmd_sharding_propagation_to_output(int index) const;
  void set_allow_spmd_sharding_propagation_to_output(int index, bool value);
  void add_allow_spmd_sharding_propagation_to_output(bool value);
  const ::google::protobuf::RepeatedField<bool>& allow_spmd_sharding_propagation_to_output() const;
  ::google::protobuf::RepeatedField<bool>* mutable_allow_spmd_sharding_propagation_to_output();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_allow_spmd_sharding_propagation_to_output() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_allow_spmd_sharding_propagation_to_output();

  public:
  // repeated int64 auto_spmd_partitioning_mesh_shape = 16;
  int auto_spmd_partitioning_mesh_shape_size() const;
  private:
  int _internal_auto_spmd_partitioning_mesh_shape_size() const;

  public:
  void clear_auto_spmd_partitioning_mesh_shape() ;
  ::int64_t auto_spmd_partitioning_mesh_shape(int index) const;
  void set_auto_spmd_partitioning_mesh_shape(int index, ::int64_t value);
  void add_auto_spmd_partitioning_mesh_shape(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& auto_spmd_partitioning_mesh_shape() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_auto_spmd_partitioning_mesh_shape();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_auto_spmd_partitioning_mesh_shape() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_auto_spmd_partitioning_mesh_shape();

  public:
  // repeated int64 auto_spmd_partitioning_mesh_ids = 17;
  int auto_spmd_partitioning_mesh_ids_size() const;
  private:
  int _internal_auto_spmd_partitioning_mesh_ids_size() const;

  public:
  void clear_auto_spmd_partitioning_mesh_ids() ;
  ::int64_t auto_spmd_partitioning_mesh_ids(int index) const;
  void set_auto_spmd_partitioning_mesh_ids(int index, ::int64_t value);
  void add_auto_spmd_partitioning_mesh_ids(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& auto_spmd_partitioning_mesh_ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_auto_spmd_partitioning_mesh_ids();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_auto_spmd_partitioning_mesh_ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_auto_spmd_partitioning_mesh_ids();

  public:
  // repeated bool param_requires_broadcast_via_collectives = 18;
  int param_requires_broadcast_via_collectives_size() const;
  private:
  int _internal_param_requires_broadcast_via_collectives_size() const;

  public:
  void clear_param_requires_broadcast_via_collectives() ;
  bool param_requires_broadcast_via_collectives(int index) const;
  void set_param_requires_broadcast_via_collectives(int index, bool value);
  void add_param_requires_broadcast_via_collectives(bool value);
  const ::google::protobuf::RepeatedField<bool>& param_requires_broadcast_via_collectives() const;
  ::google::protobuf::RepeatedField<bool>* mutable_param_requires_broadcast_via_collectives();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_param_requires_broadcast_via_collectives() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_param_requires_broadcast_via_collectives();

  public:
  // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 20;
  int shardable_value_update_pairs_size() const;
  private:
  int _internal_shardable_value_update_pairs_size() const;

  public:
  void clear_shardable_value_update_pairs() ;
  ::xla::ShardableValueUpdatePairProto* mutable_shardable_value_update_pairs(int index);
  ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* mutable_shardable_value_update_pairs();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& _internal_shardable_value_update_pairs() const;
  ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* _internal_mutable_shardable_value_update_pairs();
  public:
  const ::xla::ShardableValueUpdatePairProto& shardable_value_update_pairs(int index) const;
  ::xla::ShardableValueUpdatePairProto* add_shardable_value_update_pairs();
  const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& shardable_value_update_pairs() const;
  // repeated bool allow_spmd_sharding_propagation_to_parameters = 23;
  int allow_spmd_sharding_propagation_to_parameters_size() const;
  private:
  int _internal_allow_spmd_sharding_propagation_to_parameters_size() const;

  public:
  void clear_allow_spmd_sharding_propagation_to_parameters() ;
  bool allow_spmd_sharding_propagation_to_parameters(int index) const;
  void set_allow_spmd_sharding_propagation_to_parameters(int index, bool value);
  void add_allow_spmd_sharding_propagation_to_parameters(bool value);
  const ::google::protobuf::RepeatedField<bool>& allow_spmd_sharding_propagation_to_parameters() const;
  ::google::protobuf::RepeatedField<bool>* mutable_allow_spmd_sharding_propagation_to_parameters();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_allow_spmd_sharding_propagation_to_parameters() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_allow_spmd_sharding_propagation_to_parameters();

  public:
  // bytes fdo_profile = 21;
  void clear_fdo_profile() ;
  const std::string& fdo_profile() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fdo_profile(Arg_&& arg, Args_... args);
  std::string* mutable_fdo_profile();
  PROTOBUF_NODISCARD std::string* release_fdo_profile();
  void set_allocated_fdo_profile(std::string* value);

  private:
  const std::string& _internal_fdo_profile() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fdo_profile(
      const std::string& value);
  std::string* _internal_mutable_fdo_profile();

  public:
  // .xla.ShapeProto shape_with_output_layout = 2;
  bool has_shape_with_output_layout() const;
  void clear_shape_with_output_layout() ;
  const ::xla::ShapeProto& shape_with_output_layout() const;
  PROTOBUF_NODISCARD ::xla::ShapeProto* release_shape_with_output_layout();
  ::xla::ShapeProto* mutable_shape_with_output_layout();
  void set_allocated_shape_with_output_layout(::xla::ShapeProto* value);
  void unsafe_arena_set_allocated_shape_with_output_layout(::xla::ShapeProto* value);
  ::xla::ShapeProto* unsafe_arena_release_shape_with_output_layout();

  private:
  const ::xla::ShapeProto& _internal_shape_with_output_layout() const;
  ::xla::ShapeProto* _internal_mutable_shape_with_output_layout();

  public:
  // .xla.DebugOptions debug_options = 4;
  bool has_debug_options() const;
  void clear_debug_options() ;
  const ::xla::DebugOptions& debug_options() const;
  PROTOBUF_NODISCARD ::xla::DebugOptions* release_debug_options();
  ::xla::DebugOptions* mutable_debug_options();
  void set_allocated_debug_options(::xla::DebugOptions* value);
  void unsafe_arena_set_allocated_debug_options(::xla::DebugOptions* value);
  ::xla::DebugOptions* unsafe_arena_release_debug_options();

  private:
  const ::xla::DebugOptions& _internal_debug_options() const;
  ::xla::DebugOptions* _internal_mutable_debug_options();

  public:
  // .xla.DeviceAssignmentProto device_assignment = 7;
  bool has_device_assignment() const;
  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* value);
  void unsafe_arena_set_allocated_device_assignment(::xla::DeviceAssignmentProto* value);
  ::xla::DeviceAssignmentProto* unsafe_arena_release_device_assignment();

  private:
  const ::xla::DeviceAssignmentProto& _internal_device_assignment() const;
  ::xla::DeviceAssignmentProto* _internal_mutable_device_assignment();

  public:
  // uint64 seed = 3;
  void clear_seed() ;
  ::uint64_t seed() const;
  void set_seed(::uint64_t value);

  private:
  ::uint64_t _internal_seed() const;
  void _internal_set_seed(::uint64_t value);

  public:
  // int32 num_replicas = 6;
  void clear_num_replicas() ;
  ::int32_t num_replicas() const;
  void set_num_replicas(::int32_t value);

  private:
  ::int32_t _internal_num_replicas() const;
  void _internal_set_num_replicas(::int32_t value);

  public:
  // int32 num_partitions = 9;
  void clear_num_partitions() ;
  ::int32_t num_partitions() const;
  void set_num_partitions(::int32_t value);

  private:
  ::int32_t _internal_num_partitions() const;
  void _internal_set_num_partitions(::int32_t value);

  public:
  // int32 launch_id = 10;
  void clear_launch_id() ;
  ::int32_t launch_id() const;
  void set_launch_id(::int32_t value);

  private:
  ::int32_t _internal_launch_id() const;
  void _internal_set_launch_id(::int32_t value);

  public:
  // bool alias_passthrough_params = 8;
  void clear_alias_passthrough_params() ;
  bool alias_passthrough_params() const;
  void set_alias_passthrough_params(bool value);

  private:
  bool _internal_alias_passthrough_params() const;
  void _internal_set_alias_passthrough_params(bool value);

  public:
  // bool use_spmd_partitioning = 11;
  void clear_use_spmd_partitioning() ;
  bool use_spmd_partitioning() const;
  void set_use_spmd_partitioning(bool value);

  private:
  bool _internal_use_spmd_partitioning() const;
  void _internal_set_use_spmd_partitioning(bool value);

  public:
  // bool use_auto_spmd_partitioning = 15;
  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:
  // bool deduplicate_hlo = 12;
  void clear_deduplicate_hlo() ;
  bool deduplicate_hlo() const;
  void set_deduplicate_hlo(bool value);

  private:
  bool _internal_deduplicate_hlo() const;
  void _internal_set_deduplicate_hlo(bool value);

  public:
  // int64 device_memory_size = 22;
  void clear_device_memory_size() ;
  ::int64_t device_memory_size() const;
  void set_device_memory_size(::int64_t value);

  private:
  ::int64_t _internal_device_memory_size() const;
  void _internal_set_device_memory_size(::int64_t value);

  public:
  // bool allow_separate_sharding_programs = 19;
  void clear_allow_separate_sharding_programs() ;
  bool allow_separate_sharding_programs() const;
  void set_allow_separate_sharding_programs(bool value);

  private:
  bool _internal_allow_separate_sharding_programs() const;
  void _internal_set_allow_separate_sharding_programs(bool value);

  public:
  // bool use_shardy_partitioner = 24;
  void clear_use_shardy_partitioner() ;
  bool use_shardy_partitioner() const;
  void set_use_shardy_partitioner(bool value);

  private:
  bool _internal_use_shardy_partitioner() const;
  void _internal_set_use_shardy_partitioner(bool value);

  public:
  // float exec_time_optimization_effort = 25 [deprecated = true];
  [[deprecated]]  void clear_exec_time_optimization_effort() ;
  [[deprecated]] float exec_time_optimization_effort() const;
  [[deprecated]] void set_exec_time_optimization_effort(float value);

  private:
  float _internal_exec_time_optimization_effort() const;
  void _internal_set_exec_time_optimization_effort(float value);

  public:
  // float memory_fitting_effort = 26 [deprecated = true];
  [[deprecated]]  void clear_memory_fitting_effort() ;
  [[deprecated]] float memory_fitting_effort() const;
  [[deprecated]] void set_memory_fitting_effort(float value);

  private:
  float _internal_memory_fitting_effort() const;
  void _internal_set_memory_fitting_effort(float value);

  public:
  // .xla.ExecutionOptions.EffortLevel optimization_level = 27;
  void clear_optimization_level() ;
  ::xla::ExecutionOptions_EffortLevel optimization_level() const;
  void set_optimization_level(::xla::ExecutionOptions_EffortLevel value);

  private:
  ::xla::ExecutionOptions_EffortLevel _internal_optimization_level() const;
  void _internal_set_optimization_level(::xla::ExecutionOptions_EffortLevel value);

  public:
  // .xla.ExecutionOptions.EffortLevel memory_fitting_level = 28;
  void clear_memory_fitting_level() ;
  ::xla::ExecutionOptions_EffortLevel memory_fitting_level() const;
  void set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value);

  private:
  ::xla::ExecutionOptions_EffortLevel _internal_memory_fitting_level() const;
  void _internal_set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value);

  public:
  // @@protoc_insertion_point(class_scope:xla.ExecutionOptions)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 26, 5,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ExecutionOptions& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::DeviceHandle > device_handles_;
    ::google::protobuf::RepeatedField<bool> allow_spmd_sharding_propagation_to_output_;
    ::google::protobuf::RepeatedField<::int64_t> auto_spmd_partitioning_mesh_shape_;
    mutable ::google::protobuf::internal::CachedSize _auto_spmd_partitioning_mesh_shape_cached_byte_size_;
    ::google::protobuf::RepeatedField<::int64_t> auto_spmd_partitioning_mesh_ids_;
    mutable ::google::protobuf::internal::CachedSize _auto_spmd_partitioning_mesh_ids_cached_byte_size_;
    ::google::protobuf::RepeatedField<bool> param_requires_broadcast_via_collectives_;
    ::google::protobuf::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto > shardable_value_update_pairs_;
    ::google::protobuf::RepeatedField<bool> allow_spmd_sharding_propagation_to_parameters_;
    ::google::protobuf::internal::ArenaStringPtr fdo_profile_;
    ::xla::ShapeProto* shape_with_output_layout_;
    ::xla::DebugOptions* debug_options_;
    ::xla::DeviceAssignmentProto* device_assignment_;
    ::uint64_t seed_;
    ::int32_t num_replicas_;
    ::int32_t num_partitions_;
    ::int32_t launch_id_;
    bool alias_passthrough_params_;
    bool use_spmd_partitioning_;
    bool use_auto_spmd_partitioning_;
    bool deduplicate_hlo_;
    ::int64_t device_memory_size_;
    bool allow_separate_sharding_programs_;
    bool use_shardy_partitioner_;
    float exec_time_optimization_effort_;
    float memory_fitting_effort_;
    int optimization_level_;
    int memory_fitting_level_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT NodeShardingConfigProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.NodeShardingConfigProto) */ {
 public:
  inline NodeShardingConfigProto() : NodeShardingConfigProto(nullptr) {}
  ~NodeShardingConfigProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR NodeShardingConfigProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline NodeShardingConfigProto(const NodeShardingConfigProto& from) : NodeShardingConfigProto(nullptr, from) {}
  inline NodeShardingConfigProto(NodeShardingConfigProto&& from) noexcept
      : NodeShardingConfigProto(nullptr, std::move(from)) {}
  inline NodeShardingConfigProto& operator=(const NodeShardingConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeShardingConfigProto& operator=(NodeShardingConfigProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NodeShardingConfigProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const NodeShardingConfigProto* internal_default_instance() {
    return reinterpret_cast<const NodeShardingConfigProto*>(
        &_NodeShardingConfigProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 18;
  friend void swap(NodeShardingConfigProto& a, NodeShardingConfigProto& b) { a.Swap(&b); }
  inline void Swap(NodeShardingConfigProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeShardingConfigProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  NodeShardingConfigProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<NodeShardingConfigProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NodeShardingConfigProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NodeShardingConfigProto& from) { NodeShardingConfigProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NodeShardingConfigProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.NodeShardingConfigProto"; }

 protected:
  explicit NodeShardingConfigProto(::google::protobuf::Arena* arena);
  NodeShardingConfigProto(::google::protobuf::Arena* arena, const NodeShardingConfigProto& from);
  NodeShardingConfigProto(::google::protobuf::Arena* arena, NodeShardingConfigProto&& from) noexcept
      : NodeShardingConfigProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodesFieldNumber = 2,
    kShardingFieldNumber = 1,
  };
  // repeated .xla.NodeShardingConfigProto nodes = 2;
  int nodes_size() const;
  private:
  int _internal_nodes_size() const;

  public:
  void clear_nodes() ;
  ::xla::NodeShardingConfigProto* mutable_nodes(int index);
  ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* mutable_nodes();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& _internal_nodes() const;
  ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* _internal_mutable_nodes();
  public:
  const ::xla::NodeShardingConfigProto& nodes(int index) const;
  ::xla::NodeShardingConfigProto* add_nodes();
  const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& nodes() const;
  // .xla.OpSharding sharding = 1;
  bool has_sharding() const;
  void clear_sharding() ;
  const ::xla::OpSharding& sharding() const;
  PROTOBUF_NODISCARD ::xla::OpSharding* release_sharding();
  ::xla::OpSharding* mutable_sharding();
  void set_allocated_sharding(::xla::OpSharding* value);
  void unsafe_arena_set_allocated_sharding(::xla::OpSharding* value);
  ::xla::OpSharding* unsafe_arena_release_sharding();

  private:
  const ::xla::OpSharding& _internal_sharding() const;
  ::xla::OpSharding* _internal_mutable_sharding();

  public:
  // @@protoc_insertion_point(class_scope:xla.NodeShardingConfigProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const NodeShardingConfigProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::NodeShardingConfigProto > nodes_;
    ::xla::OpSharding* sharding_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ShardingConfigProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ShardingConfigProto) */ {
 public:
  inline ShardingConfigProto() : ShardingConfigProto(nullptr) {}
  ~ShardingConfigProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ShardingConfigProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ShardingConfigProto(const ShardingConfigProto& from) : ShardingConfigProto(nullptr, from) {}
  inline ShardingConfigProto(ShardingConfigProto&& from) noexcept
      : ShardingConfigProto(nullptr, std::move(from)) {}
  inline ShardingConfigProto& operator=(const ShardingConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShardingConfigProto& operator=(ShardingConfigProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ShardingConfigProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ShardingConfigProto* internal_default_instance() {
    return reinterpret_cast<const ShardingConfigProto*>(
        &_ShardingConfigProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 19;
  friend void swap(ShardingConfigProto& a, ShardingConfigProto& b) { a.Swap(&b); }
  inline void Swap(ShardingConfigProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ShardingConfigProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ShardingConfigProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ShardingConfigProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ShardingConfigProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ShardingConfigProto& from) { ShardingConfigProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ShardingConfigProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ShardingConfigProto"; }

 protected:
  explicit ShardingConfigProto(::google::protobuf::Arena* arena);
  ShardingConfigProto(::google::protobuf::Arena* arena, const ShardingConfigProto& from);
  ShardingConfigProto(::google::protobuf::Arena* arena, ShardingConfigProto&& from) noexcept
      : ShardingConfigProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodesFieldNumber = 1,
  };
  // repeated .xla.NodeShardingConfigProto nodes = 1;
  int nodes_size() const;
  private:
  int _internal_nodes_size() const;

  public:
  void clear_nodes() ;
  ::xla::NodeShardingConfigProto* mutable_nodes(int index);
  ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* mutable_nodes();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& _internal_nodes() const;
  ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* _internal_mutable_nodes();
  public:
  const ::xla::NodeShardingConfigProto& nodes(int index) const;
  ::xla::NodeShardingConfigProto* add_nodes();
  const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& nodes() const;
  // @@protoc_insertion_point(class_scope:xla.ShardingConfigProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ShardingConfigProto& from_msg);
    ::google::protobuf::RepeatedPtrField< ::xla::NodeShardingConfigProto > nodes_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT HloModuleConfigProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto) */ {
 public:
  inline HloModuleConfigProto() : HloModuleConfigProto(nullptr) {}
  ~HloModuleConfigProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleConfigProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline HloModuleConfigProto(const HloModuleConfigProto& from) : HloModuleConfigProto(nullptr, from) {}
  inline HloModuleConfigProto(HloModuleConfigProto&& from) noexcept
      : HloModuleConfigProto(nullptr, std::move(from)) {}
  inline HloModuleConfigProto& operator=(const HloModuleConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleConfigProto& operator=(HloModuleConfigProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleConfigProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleConfigProto* internal_default_instance() {
    return reinterpret_cast<const HloModuleConfigProto*>(
        &_HloModuleConfigProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 12;
  friend void swap(HloModuleConfigProto& a, HloModuleConfigProto& b) { a.Swap(&b); }
  inline void Swap(HloModuleConfigProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HloModuleConfigProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  HloModuleConfigProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<HloModuleConfigProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HloModuleConfigProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const HloModuleConfigProto& from) { HloModuleConfigProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(HloModuleConfigProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.HloModuleConfigProto"; }

 protected:
  explicit HloModuleConfigProto(::google::protobuf::Arena* arena);
  HloModuleConfigProto(::google::protobuf::Arena* arena, const HloModuleConfigProto& from);
  HloModuleConfigProto(::google::protobuf::Arena* arena, HloModuleConfigProto&& from) noexcept
      : HloModuleConfigProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using BoolList = HloModuleConfigProto_BoolList;
  using Int64List = HloModuleConfigProto_Int64List;
  using Int64ListList = HloModuleConfigProto_Int64ListList;
  using FusionConfigCollection = HloModuleConfigProto_FusionConfigCollection;
  static constexpr FusionConfigCollection OFF = HloModuleConfigProto_FusionConfigCollection_OFF;
  static constexpr FusionConfigCollection PER_EDGE = HloModuleConfigProto_FusionConfigCollection_PER_EDGE;
  static constexpr FusionConfigCollection PER_NODE = HloModuleConfigProto_FusionConfigCollection_PER_NODE;
  static inline bool FusionConfigCollection_IsValid(int value) {
    return HloModuleConfigProto_FusionConfigCollection_IsValid(value);
  }
  static constexpr FusionConfigCollection FusionConfigCollection_MIN = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MIN;
  static constexpr FusionConfigCollection FusionConfigCollection_MAX = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MAX;
  static constexpr int FusionConfigCollection_ARRAYSIZE = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* FusionConfigCollection_descriptor() {
    return HloModuleConfigProto_FusionConfigCollection_descriptor();
  }
  template <typename T>
  static inline const std::string& FusionConfigCollection_Name(T value) {
    return HloModuleConfigProto_FusionConfigCollection_Name(value);
  }
  static inline bool FusionConfigCollection_Parse(absl::string_view name, FusionConfigCollection* value) {
    return HloModuleConfigProto_FusionConfigCollection_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kParamRequiresBroadcastViaCollectivesFieldNumber = 6,
    kAutoSpmdPartitioningMeshShapeFieldNumber = 9,
    kAutoSpmdPartitioningMeshIdsFieldNumber = 10,
    kShardableValueUpdatePairsFieldNumber = 16,
    kFusionConfigFieldNumber = 20,
    kDotConfigFieldNumber = 21,
    kLayoutConfigFieldNumber = 22,
    kMemorySpaceAssignmentConfigFieldNumber = 23,
    kPhaseOrderingConfigFieldNumber = 24,
    kAllowSpmdShardingPropagationToOutputFieldNumber = 27,
    kAnalysisAllowanceMapFieldNumber = 28,
    kAllowSpmdShardingPropagationToParametersFieldNumber = 33,
    kDeviceTypeFieldNumber = 13,
    kFdoProfileFieldNumber = 31,
    kEntryComputationLayoutFieldNumber = 1,
    kDebugOptionsFieldNumber = 14,
    kStaticDeviceAssignmentFieldNumber = 15,
    kPreSimulationDeviceAssignmentFieldNumber = 35,
    kShardingConfigFieldNumber = 38,
    kScheduleConfigFieldNumber = 41,
    kSeedFieldNumber = 2,
    kReplicaCountFieldNumber = 4,
    kNumPartitionsFieldNumber = 5,
    kLaunchIdFieldNumber = 3,
    kUseSpmdPartitioningFieldNumber = 7,
    kUseAutoSpmdPartitioningFieldNumber = 8,
    kDeduplicateHloFieldNumber = 11,
    kAllowSeparateShardingProgramsFieldNumber = 30,
    kIntraOpParallelismThreadsFieldNumber = 12,
    kFusionConfigCollectionFieldNumber = 19,
    kAliasPassthroughParamsFieldNumber = 17,
    kContentAwareComputationSortingFieldNumber = 18,
    kUseShardyPartitionerFieldNumber = 34,
    kPhaseIndexFieldNumber = 25,
    kMatrixUnitOperandPrecisionFieldNumber = 29,
    kDeviceMemorySizeFieldNumber = 32,
    kExecTimeOptimizationEffortFieldNumber = 36,
    kMemoryFittingEffortFieldNumber = 37,
    kOptimizationLevelFieldNumber = 39,
    kMemoryFittingLevelFieldNumber = 40,
  };
  // repeated bool param_requires_broadcast_via_collectives = 6;
  int param_requires_broadcast_via_collectives_size() const;
  private:
  int _internal_param_requires_broadcast_via_collectives_size() const;

  public:
  void clear_param_requires_broadcast_via_collectives() ;
  bool param_requires_broadcast_via_collectives(int index) const;
  void set_param_requires_broadcast_via_collectives(int index, bool value);
  void add_param_requires_broadcast_via_collectives(bool value);
  const ::google::protobuf::RepeatedField<bool>& param_requires_broadcast_via_collectives() const;
  ::google::protobuf::RepeatedField<bool>* mutable_param_requires_broadcast_via_collectives();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_param_requires_broadcast_via_collectives() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_param_requires_broadcast_via_collectives();

  public:
  // repeated int64 auto_spmd_partitioning_mesh_shape = 9;
  int auto_spmd_partitioning_mesh_shape_size() const;
  private:
  int _internal_auto_spmd_partitioning_mesh_shape_size() const;

  public:
  void clear_auto_spmd_partitioning_mesh_shape() ;
  ::int64_t auto_spmd_partitioning_mesh_shape(int index) const;
  void set_auto_spmd_partitioning_mesh_shape(int index, ::int64_t value);
  void add_auto_spmd_partitioning_mesh_shape(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& auto_spmd_partitioning_mesh_shape() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_auto_spmd_partitioning_mesh_shape();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_auto_spmd_partitioning_mesh_shape() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_auto_spmd_partitioning_mesh_shape();

  public:
  // repeated int64 auto_spmd_partitioning_mesh_ids = 10;
  int auto_spmd_partitioning_mesh_ids_size() const;
  private:
  int _internal_auto_spmd_partitioning_mesh_ids_size() const;

  public:
  void clear_auto_spmd_partitioning_mesh_ids() ;
  ::int64_t auto_spmd_partitioning_mesh_ids(int index) const;
  void set_auto_spmd_partitioning_mesh_ids(int index, ::int64_t value);
  void add_auto_spmd_partitioning_mesh_ids(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& auto_spmd_partitioning_mesh_ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* mutable_auto_spmd_partitioning_mesh_ids();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_auto_spmd_partitioning_mesh_ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_auto_spmd_partitioning_mesh_ids();

  public:
  // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 16;
  int shardable_value_update_pairs_size() const;
  private:
  int _internal_shardable_value_update_pairs_size() const;

  public:
  void clear_shardable_value_update_pairs() ;
  ::xla::ShardableValueUpdatePairProto* mutable_shardable_value_update_pairs(int index);
  ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* mutable_shardable_value_update_pairs();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& _internal_shardable_value_update_pairs() const;
  ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* _internal_mutable_shardable_value_update_pairs();
  public:
  const ::xla::ShardableValueUpdatePairProto& shardable_value_update_pairs(int index) const;
  ::xla::ShardableValueUpdatePairProto* add_shardable_value_update_pairs();
  const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& shardable_value_update_pairs() const;
  // repeated .xla.HloModuleConfigProto.BoolList fusion_config = 20;
  int fusion_config_size() const;
  private:
  int _internal_fusion_config_size() const;

  public:
  void clear_fusion_config() ;
  ::xla::HloModuleConfigProto_BoolList* mutable_fusion_config(int index);
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* mutable_fusion_config();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& _internal_fusion_config() const;
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* _internal_mutable_fusion_config();
  public:
  const ::xla::HloModuleConfigProto_BoolList& fusion_config(int index) const;
  ::xla::HloModuleConfigProto_BoolList* add_fusion_config();
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& fusion_config() const;
  // map<string, .xla.HloModuleConfigProto.Int64List> dot_config = 21;
  int dot_config_size() const;
  private:
  int _internal_dot_config_size() const;

  public:
  void clear_dot_config() ;
  const ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>& dot_config() const;
  ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>* mutable_dot_config();

  private:
  const ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>& _internal_dot_config() const;
  ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>* _internal_mutable_dot_config();

  public:
  // repeated .xla.HloModuleConfigProto.Int64ListList layout_config = 22;
  int layout_config_size() const;
  private:
  int _internal_layout_config_size() const;

  public:
  void clear_layout_config() ;
  ::xla::HloModuleConfigProto_Int64ListList* mutable_layout_config(int index);
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>* mutable_layout_config();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>& _internal_layout_config() const;
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>* _internal_mutable_layout_config();
  public:
  const ::xla::HloModuleConfigProto_Int64ListList& layout_config(int index) const;
  ::xla::HloModuleConfigProto_Int64ListList* add_layout_config();
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>& layout_config() const;
  // repeated uint64 memory_space_assignment_config = 23;
  int memory_space_assignment_config_size() const;
  private:
  int _internal_memory_space_assignment_config_size() const;

  public:
  void clear_memory_space_assignment_config() ;
  ::uint64_t memory_space_assignment_config(int index) const;
  void set_memory_space_assignment_config(int index, ::uint64_t value);
  void add_memory_space_assignment_config(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& memory_space_assignment_config() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_memory_space_assignment_config();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_memory_space_assignment_config() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_memory_space_assignment_config();

  public:
  // repeated .xla.HloModuleConfigProto.BoolList phase_ordering_config = 24;
  int phase_ordering_config_size() const;
  private:
  int _internal_phase_ordering_config_size() const;

  public:
  void clear_phase_ordering_config() ;
  ::xla::HloModuleConfigProto_BoolList* mutable_phase_ordering_config(int index);
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* mutable_phase_ordering_config();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& _internal_phase_ordering_config() const;
  ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* _internal_mutable_phase_ordering_config();
  public:
  const ::xla::HloModuleConfigProto_BoolList& phase_ordering_config(int index) const;
  ::xla::HloModuleConfigProto_BoolList* add_phase_ordering_config();
  const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& phase_ordering_config() const;
  // repeated bool allow_spmd_sharding_propagation_to_output = 27;
  int allow_spmd_sharding_propagation_to_output_size() const;
  private:
  int _internal_allow_spmd_sharding_propagation_to_output_size() const;

  public:
  void clear_allow_spmd_sharding_propagation_to_output() ;
  bool allow_spmd_sharding_propagation_to_output(int index) const;
  void set_allow_spmd_sharding_propagation_to_output(int index, bool value);
  void add_allow_spmd_sharding_propagation_to_output(bool value);
  const ::google::protobuf::RepeatedField<bool>& allow_spmd_sharding_propagation_to_output() const;
  ::google::protobuf::RepeatedField<bool>* mutable_allow_spmd_sharding_propagation_to_output();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_allow_spmd_sharding_propagation_to_output() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_allow_spmd_sharding_propagation_to_output();

  public:
  // map<string, int64> analysis_allowance_map = 28;
  int analysis_allowance_map_size() const;
  private:
  int _internal_analysis_allowance_map_size() const;

  public:
  void clear_analysis_allowance_map() ;
  const ::google::protobuf::Map<std::string, ::int64_t>& analysis_allowance_map() const;
  ::google::protobuf::Map<std::string, ::int64_t>* mutable_analysis_allowance_map();

  private:
  const ::google::protobuf::Map<std::string, ::int64_t>& _internal_analysis_allowance_map() const;
  ::google::protobuf::Map<std::string, ::int64_t>* _internal_mutable_analysis_allowance_map();

  public:
  // repeated bool allow_spmd_sharding_propagation_to_parameters = 33;
  int allow_spmd_sharding_propagation_to_parameters_size() const;
  private:
  int _internal_allow_spmd_sharding_propagation_to_parameters_size() const;

  public:
  void clear_allow_spmd_sharding_propagation_to_parameters() ;
  bool allow_spmd_sharding_propagation_to_parameters(int index) const;
  void set_allow_spmd_sharding_propagation_to_parameters(int index, bool value);
  void add_allow_spmd_sharding_propagation_to_parameters(bool value);
  const ::google::protobuf::RepeatedField<bool>& allow_spmd_sharding_propagation_to_parameters() const;
  ::google::protobuf::RepeatedField<bool>* mutable_allow_spmd_sharding_propagation_to_parameters();

  private:
  const ::google::protobuf::RepeatedField<bool>& _internal_allow_spmd_sharding_propagation_to_parameters() const;
  ::google::protobuf::RepeatedField<bool>* _internal_mutable_allow_spmd_sharding_propagation_to_parameters();

  public:
  // string device_type = 13;
  void clear_device_type() ;
  const std::string& device_type() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_device_type(Arg_&& arg, Args_... args);
  std::string* mutable_device_type();
  PROTOBUF_NODISCARD std::string* release_device_type();
  void set_allocated_device_type(std::string* value);

  private:
  const std::string& _internal_device_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(
      const std::string& value);
  std::string* _internal_mutable_device_type();

  public:
  // bytes fdo_profile = 31;
  void clear_fdo_profile() ;
  const std::string& fdo_profile() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fdo_profile(Arg_&& arg, Args_... args);
  std::string* mutable_fdo_profile();
  PROTOBUF_NODISCARD std::string* release_fdo_profile();
  void set_allocated_fdo_profile(std::string* value);

  private:
  const std::string& _internal_fdo_profile() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fdo_profile(
      const std::string& value);
  std::string* _internal_mutable_fdo_profile();

  public:
  // .xla.ProgramShapeProto entry_computation_layout = 1;
  bool has_entry_computation_layout() const;
  void clear_entry_computation_layout() ;
  const ::xla::ProgramShapeProto& entry_computation_layout() const;
  PROTOBUF_NODISCARD ::xla::ProgramShapeProto* release_entry_computation_layout();
  ::xla::ProgramShapeProto* mutable_entry_computation_layout();
  void set_allocated_entry_computation_layout(::xla::ProgramShapeProto* value);
  void unsafe_arena_set_allocated_entry_computation_layout(::xla::ProgramShapeProto* value);
  ::xla::ProgramShapeProto* unsafe_arena_release_entry_computation_layout();

  private:
  const ::xla::ProgramShapeProto& _internal_entry_computation_layout() const;
  ::xla::ProgramShapeProto* _internal_mutable_entry_computation_layout();

  public:
  // .xla.DebugOptions debug_options = 14;
  bool has_debug_options() const;
  void clear_debug_options() ;
  const ::xla::DebugOptions& debug_options() const;
  PROTOBUF_NODISCARD ::xla::DebugOptions* release_debug_options();
  ::xla::DebugOptions* mutable_debug_options();
  void set_allocated_debug_options(::xla::DebugOptions* value);
  void unsafe_arena_set_allocated_debug_options(::xla::DebugOptions* value);
  ::xla::DebugOptions* unsafe_arena_release_debug_options();

  private:
  const ::xla::DebugOptions& _internal_debug_options() const;
  ::xla::DebugOptions* _internal_mutable_debug_options();

  public:
  // .xla.DeviceAssignmentProto static_device_assignment = 15;
  bool has_static_device_assignment() const;
  void clear_static_device_assignment() ;
  const ::xla::DeviceAssignmentProto& static_device_assignment() const;
  PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_static_device_assignment();
  ::xla::DeviceAssignmentProto* mutable_static_device_assignment();
  void set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* value);
  void unsafe_arena_set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* value);
  ::xla::DeviceAssignmentProto* unsafe_arena_release_static_device_assignment();

  private:
  const ::xla::DeviceAssignmentProto& _internal_static_device_assignment() const;
  ::xla::DeviceAssignmentProto* _internal_mutable_static_device_assignment();

  public:
  // .xla.DeviceAssignmentProto pre_simulation_device_assignment = 35;
  bool has_pre_simulation_device_assignment() const;
  void clear_pre_simulation_device_assignment() ;
  const ::xla::DeviceAssignmentProto& pre_simulation_device_assignment() const;
  PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_pre_simulation_device_assignment();
  ::xla::DeviceAssignmentProto* mutable_pre_simulation_device_assignment();
  void set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* value);
  void unsafe_arena_set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* value);
  ::xla::DeviceAssignmentProto* unsafe_arena_release_pre_simulation_device_assignment();

  private:
  const ::xla::DeviceAssignmentProto& _internal_pre_simulation_device_assignment() const;
  ::xla::DeviceAssignmentProto* _internal_mutable_pre_simulation_device_assignment();

  public:
  // .xla.ShardingConfigProto sharding_config = 38;
  bool has_sharding_config() const;
  void clear_sharding_config() ;
  const ::xla::ShardingConfigProto& sharding_config() const;
  PROTOBUF_NODISCARD ::xla::ShardingConfigProto* release_sharding_config();
  ::xla::ShardingConfigProto* mutable_sharding_config();
  void set_allocated_sharding_config(::xla::ShardingConfigProto* value);
  void unsafe_arena_set_allocated_sharding_config(::xla::ShardingConfigProto* value);
  ::xla::ShardingConfigProto* unsafe_arena_release_sharding_config();

  private:
  const ::xla::ShardingConfigProto& _internal_sharding_config() const;
  ::xla::ShardingConfigProto* _internal_mutable_sharding_config();

  public:
  // .xla.ScheduleConfigProto schedule_config = 41;
  bool has_schedule_config() const;
  void clear_schedule_config() ;
  const ::xla::ScheduleConfigProto& schedule_config() const;
  PROTOBUF_NODISCARD ::xla::ScheduleConfigProto* release_schedule_config();
  ::xla::ScheduleConfigProto* mutable_schedule_config();
  void set_allocated_schedule_config(::xla::ScheduleConfigProto* value);
  void unsafe_arena_set_allocated_schedule_config(::xla::ScheduleConfigProto* value);
  ::xla::ScheduleConfigProto* unsafe_arena_release_schedule_config();

  private:
  const ::xla::ScheduleConfigProto& _internal_schedule_config() const;
  ::xla::ScheduleConfigProto* _internal_mutable_schedule_config();

  public:
  // uint64 seed = 2;
  void clear_seed() ;
  ::uint64_t seed() const;
  void set_seed(::uint64_t value);

  private:
  ::uint64_t _internal_seed() const;
  void _internal_set_seed(::uint64_t value);

  public:
  // int64 replica_count = 4;
  void clear_replica_count() ;
  ::int64_t replica_count() const;
  void set_replica_count(::int64_t value);

  private:
  ::int64_t _internal_replica_count() const;
  void _internal_set_replica_count(::int64_t value);

  public:
  // int64 num_partitions = 5;
  void clear_num_partitions() ;
  ::int64_t num_partitions() const;
  void set_num_partitions(::int64_t value);

  private:
  ::int64_t _internal_num_partitions() const;
  void _internal_set_num_partitions(::int64_t value);

  public:
  // int32 launch_id = 3;
  void clear_launch_id() ;
  ::int32_t launch_id() const;
  void set_launch_id(::int32_t value);

  private:
  ::int32_t _internal_launch_id() const;
  void _internal_set_launch_id(::int32_t value);

  public:
  // bool use_spmd_partitioning = 7;
  void clear_use_spmd_partitioning() ;
  bool use_spmd_partitioning() const;
  void set_use_spmd_partitioning(bool value);

  private:
  bool _internal_use_spmd_partitioning() const;
  void _internal_set_use_spmd_partitioning(bool value);

  public:
  // bool use_auto_spmd_partitioning = 8;
  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:
  // bool deduplicate_hlo = 11;
  void clear_deduplicate_hlo() ;
  bool deduplicate_hlo() const;
  void set_deduplicate_hlo(bool value);

  private:
  bool _internal_deduplicate_hlo() const;
  void _internal_set_deduplicate_hlo(bool value);

  public:
  // bool allow_separate_sharding_programs = 30;
  void clear_allow_separate_sharding_programs() ;
  bool allow_separate_sharding_programs() const;
  void set_allow_separate_sharding_programs(bool value);

  private:
  bool _internal_allow_separate_sharding_programs() const;
  void _internal_set_allow_separate_sharding_programs(bool value);

  public:
  // int64 intra_op_parallelism_threads = 12;
  void clear_intra_op_parallelism_threads() ;
  ::int64_t intra_op_parallelism_threads() const;
  void set_intra_op_parallelism_threads(::int64_t value);

  private:
  ::int64_t _internal_intra_op_parallelism_threads() const;
  void _internal_set_intra_op_parallelism_threads(::int64_t value);

  public:
  // .xla.HloModuleConfigProto.FusionConfigCollection fusion_config_collection = 19;
  void clear_fusion_config_collection() ;
  ::xla::HloModuleConfigProto_FusionConfigCollection fusion_config_collection() const;
  void set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value);

  private:
  ::xla::HloModuleConfigProto_FusionConfigCollection _internal_fusion_config_collection() const;
  void _internal_set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value);

  public:
  // bool alias_passthrough_params = 17;
  void clear_alias_passthrough_params() ;
  bool alias_passthrough_params() const;
  void set_alias_passthrough_params(bool value);

  private:
  bool _internal_alias_passthrough_params() const;
  void _internal_set_alias_passthrough_params(bool value);

  public:
  // bool content_aware_computation_sorting = 18;
  void clear_content_aware_computation_sorting() ;
  bool content_aware_computation_sorting() const;
  void set_content_aware_computation_sorting(bool value);

  private:
  bool _internal_content_aware_computation_sorting() const;
  void _internal_set_content_aware_computation_sorting(bool value);

  public:
  // bool use_shardy_partitioner = 34;
  void clear_use_shardy_partitioner() ;
  bool use_shardy_partitioner() const;
  void set_use_shardy_partitioner(bool value);

  private:
  bool _internal_use_shardy_partitioner() const;
  void _internal_set_use_shardy_partitioner(bool value);

  public:
  // int32 phase_index = 25;
  void clear_phase_index() ;
  ::int32_t phase_index() const;
  void set_phase_index(::int32_t value);

  private:
  ::int32_t _internal_phase_index() const;
  void _internal_set_phase_index(::int32_t value);

  public:
  // .xla.PrecisionConfig.Precision matrix_unit_operand_precision = 29;
  void clear_matrix_unit_operand_precision() ;
  ::xla::PrecisionConfig_Precision matrix_unit_operand_precision() const;
  void set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value);

  private:
  ::xla::PrecisionConfig_Precision _internal_matrix_unit_operand_precision() const;
  void _internal_set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value);

  public:
  // int64 device_memory_size = 32;
  void clear_device_memory_size() ;
  ::int64_t device_memory_size() const;
  void set_device_memory_size(::int64_t value);

  private:
  ::int64_t _internal_device_memory_size() const;
  void _internal_set_device_memory_size(::int64_t value);

  public:
  // float exec_time_optimization_effort = 36 [deprecated = true];
  [[deprecated]]  void clear_exec_time_optimization_effort() ;
  [[deprecated]] float exec_time_optimization_effort() const;
  [[deprecated]] void set_exec_time_optimization_effort(float value);

  private:
  float _internal_exec_time_optimization_effort() const;
  void _internal_set_exec_time_optimization_effort(float value);

  public:
  // float memory_fitting_effort = 37 [deprecated = true];
  [[deprecated]]  void clear_memory_fitting_effort() ;
  [[deprecated]] float memory_fitting_effort() const;
  [[deprecated]] void set_memory_fitting_effort(float value);

  private:
  float _internal_memory_fitting_effort() const;
  void _internal_set_memory_fitting_effort(float value);

  public:
  // .xla.ExecutionOptions.EffortLevel optimization_level = 39;
  void clear_optimization_level() ;
  ::xla::ExecutionOptions_EffortLevel optimization_level() const;
  void set_optimization_level(::xla::ExecutionOptions_EffortLevel value);

  private:
  ::xla::ExecutionOptions_EffortLevel _internal_optimization_level() const;
  void _internal_set_optimization_level(::xla::ExecutionOptions_EffortLevel value);

  public:
  // .xla.ExecutionOptions.EffortLevel memory_fitting_level = 40;
  void clear_memory_fitting_level() ;
  ::xla::ExecutionOptions_EffortLevel memory_fitting_level() const;
  void set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value);

  private:
  ::xla::ExecutionOptions_EffortLevel _internal_memory_fitting_level() const;
  void _internal_set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value);

  public:
  // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 40, 13,
      116, 7>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const HloModuleConfigProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<bool> param_requires_broadcast_via_collectives_;
    ::google::protobuf::RepeatedField<::int64_t> auto_spmd_partitioning_mesh_shape_;
    mutable ::google::protobuf::internal::CachedSize _auto_spmd_partitioning_mesh_shape_cached_byte_size_;
    ::google::protobuf::RepeatedField<::int64_t> auto_spmd_partitioning_mesh_ids_;
    mutable ::google::protobuf::internal::CachedSize _auto_spmd_partitioning_mesh_ids_cached_byte_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto > shardable_value_update_pairs_;
    ::google::protobuf::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList > fusion_config_;
    ::google::protobuf::internal::MapField<HloModuleConfigProto_DotConfigEntry_DoNotUse, std::string, ::xla::HloModuleConfigProto_Int64List,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>
        dot_config_;
    ::google::protobuf::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList > layout_config_;
    ::google::protobuf::RepeatedField<::uint64_t> memory_space_assignment_config_;
    mutable ::google::protobuf::internal::CachedSize _memory_space_assignment_config_cached_byte_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList > phase_ordering_config_;
    ::google::protobuf::RepeatedField<bool> allow_spmd_sharding_propagation_to_output_;
    ::google::protobuf::internal::MapField<HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse, std::string, ::int64_t,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_INT64>
        analysis_allowance_map_;
    ::google::protobuf::RepeatedField<bool> allow_spmd_sharding_propagation_to_parameters_;
    ::google::protobuf::internal::ArenaStringPtr device_type_;
    ::google::protobuf::internal::ArenaStringPtr fdo_profile_;
    ::xla::ProgramShapeProto* entry_computation_layout_;
    ::xla::DebugOptions* debug_options_;
    ::xla::DeviceAssignmentProto* static_device_assignment_;
    ::xla::DeviceAssignmentProto* pre_simulation_device_assignment_;
    ::xla::ShardingConfigProto* sharding_config_;
    ::xla::ScheduleConfigProto* schedule_config_;
    ::uint64_t seed_;
    ::int64_t replica_count_;
    ::int64_t num_partitions_;
    ::int32_t launch_id_;
    bool use_spmd_partitioning_;
    bool use_auto_spmd_partitioning_;
    bool deduplicate_hlo_;
    bool allow_separate_sharding_programs_;
    ::int64_t intra_op_parallelism_threads_;
    int fusion_config_collection_;
    bool alias_passthrough_params_;
    bool content_aware_computation_sorting_;
    bool use_shardy_partitioner_;
    ::int32_t phase_index_;
    int matrix_unit_operand_precision_;
    ::int64_t device_memory_size_;
    float exec_time_optimization_effort_;
    float memory_fitting_effort_;
    int optimization_level_;
    int memory_fitting_level_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT ScheduleProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.ScheduleProto) */ {
 public:
  inline ScheduleProto() : ScheduleProto(nullptr) {}
  ~ScheduleProto() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ScheduleProto(
      ::google::protobuf::internal::ConstantInitialized);

  inline ScheduleProto(const ScheduleProto& from) : ScheduleProto(nullptr, from) {}
  inline ScheduleProto(ScheduleProto&& from) noexcept
      : ScheduleProto(nullptr, std::move(from)) {}
  inline ScheduleProto& operator=(const ScheduleProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScheduleProto& operator=(ScheduleProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScheduleProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScheduleProto* internal_default_instance() {
    return reinterpret_cast<const ScheduleProto*>(
        &_ScheduleProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 17;
  friend void swap(ScheduleProto& a, ScheduleProto& b) { a.Swap(&b); }
  inline void Swap(ScheduleProto* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScheduleProto* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScheduleProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<ScheduleProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScheduleProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ScheduleProto& from) { ScheduleProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScheduleProto* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.ScheduleProto"; }

 protected:
  explicit ScheduleProto(::google::protobuf::Arena* arena);
  ScheduleProto(::google::protobuf::Arena* arena, const ScheduleProto& from);
  ScheduleProto(::google::protobuf::Arena* arena, ScheduleProto&& from) noexcept
      : ScheduleProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Instruction = ScheduleProto_Instruction;
  using SchedulerStatisticsProto = ScheduleProto_SchedulerStatisticsProto;
  using ComputationScheduleProto = ScheduleProto_ComputationScheduleProto;

  // accessors -------------------------------------------------------
  enum : int {
    kComputationSchedulesFieldNumber = 2,
    kHloModuleFieldNumber = 1,
  };
  // repeated .xla.ScheduleProto.ComputationScheduleProto computation_schedules = 2;
  int computation_schedules_size() const;
  private:
  int _internal_computation_schedules_size() const;

  public:
  void clear_computation_schedules() ;
  ::xla::ScheduleProto_ComputationScheduleProto* mutable_computation_schedules(int index);
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>* mutable_computation_schedules();

  private:
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>& _internal_computation_schedules() const;
  ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>* _internal_mutable_computation_schedules();
  public:
  const ::xla::ScheduleProto_ComputationScheduleProto& computation_schedules(int index) const;
  ::xla::ScheduleProto_ComputationScheduleProto* add_computation_schedules();
  const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>& computation_schedules() const;
  // .xla.HloModuleProto hlo_module = 1;
  bool has_hlo_module() const;
  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* value);
  void unsafe_arena_set_allocated_hlo_module(::xla::HloModuleProto* value);
  ::xla::HloModuleProto* unsafe_arena_release_hlo_module();

  private:
  const ::xla::HloModuleProto& _internal_hlo_module() const;
  ::xla::HloModuleProto* _internal_mutable_hlo_module();

  public:
  // @@protoc_insertion_point(class_scope:xla.ScheduleProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const ScheduleProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::xla::ScheduleProto_ComputationScheduleProto > computation_schedules_;
    ::xla::HloModuleProto* hlo_module_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT HloModuleProtoWithConfig final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:xla.HloModuleProtoWithConfig) */ {
 public:
  inline HloModuleProtoWithConfig() : HloModuleProtoWithConfig(nullptr) {}
  ~HloModuleProtoWithConfig() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR HloModuleProtoWithConfig(
      ::google::protobuf::internal::ConstantInitialized);

  inline HloModuleProtoWithConfig(const HloModuleProtoWithConfig& from) : HloModuleProtoWithConfig(nullptr, from) {}
  inline HloModuleProtoWithConfig(HloModuleProtoWithConfig&& from) noexcept
      : HloModuleProtoWithConfig(nullptr, std::move(from)) {}
  inline HloModuleProtoWithConfig& operator=(const HloModuleProtoWithConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleProtoWithConfig& operator=(HloModuleProtoWithConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleProtoWithConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleProtoWithConfig* internal_default_instance() {
    return reinterpret_cast<const HloModuleProtoWithConfig*>(
        &_HloModuleProtoWithConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 13;
  friend void swap(HloModuleProtoWithConfig& a, HloModuleProtoWithConfig& b) { a.Swap(&b); }
  inline void Swap(HloModuleProtoWithConfig* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HloModuleProtoWithConfig* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  HloModuleProtoWithConfig* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<HloModuleProtoWithConfig>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HloModuleProtoWithConfig& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const HloModuleProtoWithConfig& from) { HloModuleProtoWithConfig::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(HloModuleProtoWithConfig* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "xla.HloModuleProtoWithConfig"; }

 protected:
  explicit HloModuleProtoWithConfig(::google::protobuf::Arena* arena);
  HloModuleProtoWithConfig(::google::protobuf::Arena* arena, const HloModuleProtoWithConfig& from);
  HloModuleProtoWithConfig(::google::protobuf::Arena* arena, HloModuleProtoWithConfig&& from) noexcept
      : HloModuleProtoWithConfig(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kHloModuleFieldNumber = 1,
    kConfigFieldNumber = 2,
  };
  // .xla.HloModuleProto hlo_module = 1;
  bool has_hlo_module() const;
  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* value);
  void unsafe_arena_set_allocated_hlo_module(::xla::HloModuleProto* value);
  ::xla::HloModuleProto* unsafe_arena_release_hlo_module();

  private:
  const ::xla::HloModuleProto& _internal_hlo_module() const;
  ::xla::HloModuleProto* _internal_mutable_hlo_module();

  public:
  // .xla.HloModuleConfigProto config = 2;
  bool has_config() const;
  void clear_config() ;
  const ::xla::HloModuleConfigProto& config() const;
  PROTOBUF_NODISCARD ::xla::HloModuleConfigProto* release_config();
  ::xla::HloModuleConfigProto* mutable_config();
  void set_allocated_config(::xla::HloModuleConfigProto* value);
  void unsafe_arena_set_allocated_config(::xla::HloModuleConfigProto* value);
  ::xla::HloModuleConfigProto* unsafe_arena_release_config();

  private:
  const ::xla::HloModuleConfigProto& _internal_config() const;
  ::xla::HloModuleConfigProto* _internal_mutable_config();

  public:
  // @@protoc_insertion_point(class_scope:xla.HloModuleProtoWithConfig)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const HloModuleProtoWithConfig& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::xla::HloModuleProto* hlo_module_;
    ::xla::HloModuleConfigProto* config_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fxla_2eproto;
};

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




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


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

// CompilationEnvironmentsProto

// repeated .google.protobuf.Any environments = 1;
inline int CompilationEnvironmentsProto::_internal_environments_size() const {
  return _internal_environments().size();
}
inline int CompilationEnvironmentsProto::environments_size() const {
  return _internal_environments_size();
}
inline ::google::protobuf::Any* CompilationEnvironmentsProto::mutable_environments(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.CompilationEnvironmentsProto.environments)
  return _internal_mutable_environments()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>* CompilationEnvironmentsProto::mutable_environments()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.CompilationEnvironmentsProto.environments)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_environments();
}
inline const ::google::protobuf::Any& CompilationEnvironmentsProto::environments(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.CompilationEnvironmentsProto.environments)
  return _internal_environments().Get(index);
}
inline ::google::protobuf::Any* CompilationEnvironmentsProto::add_environments() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::Any* _add = _internal_mutable_environments()->Add();
  // @@protoc_insertion_point(field_add:xla.CompilationEnvironmentsProto.environments)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>& CompilationEnvironmentsProto::environments() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.CompilationEnvironmentsProto.environments)
  return _internal_environments();
}
inline const ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>&
CompilationEnvironmentsProto::_internal_environments() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.environments_;
}
inline ::google::protobuf::RepeatedPtrField<::google::protobuf::Any>*
CompilationEnvironmentsProto::_internal_mutable_environments() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.environments_;
}

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

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

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

// DebugOptions

// optional bool xla_hlo_pass_fix_detect_cycles = 370;
inline bool DebugOptions::has_xla_hlo_pass_fix_detect_cycles() const {
  bool value = (_impl_._has_bits_[6] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_hlo_pass_fix_detect_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_pass_fix_detect_cycles_ = false;
  _impl_._has_bits_[6] &= ~0x04000000u;
}
inline bool DebugOptions::xla_hlo_pass_fix_detect_cycles() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_pass_fix_detect_cycles)
  return _internal_xla_hlo_pass_fix_detect_cycles();
}
inline void DebugOptions::set_xla_hlo_pass_fix_detect_cycles(bool value) {
  _internal_set_xla_hlo_pass_fix_detect_cycles(value);
  _impl_._has_bits_[6] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_pass_fix_detect_cycles)
}
inline bool DebugOptions::_internal_xla_hlo_pass_fix_detect_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_hlo_pass_fix_detect_cycles_;
}
inline void DebugOptions::_internal_set_xla_hlo_pass_fix_detect_cycles(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_pass_fix_detect_cycles_ = value;
}

// optional bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations = 363;
inline bool DebugOptions::has_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const {
  bool value = (_impl_._has_bits_[6] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_ = false;
  _impl_._has_bits_[6] &= ~0x08000000u;
}
inline bool DebugOptions::xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_fix_max_iterations)
  return _internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations();
}
inline void DebugOptions::set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value) {
  _internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(value);
  _impl_._has_bits_[6] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_fix_max_iterations)
}
inline bool DebugOptions::_internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_;
}
inline void DebugOptions::_internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_ = value;
}

// optional bool xla_unsupported_crash_on_hlo_pass_noop_change = 379;
inline bool DebugOptions::has_xla_unsupported_crash_on_hlo_pass_noop_change() const {
  bool value = (_impl_._has_bits_[6] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_unsupported_crash_on_hlo_pass_noop_change() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_noop_change_ = false;
  _impl_._has_bits_[6] &= ~0x10000000u;
}
inline bool DebugOptions::xla_unsupported_crash_on_hlo_pass_noop_change() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_noop_change)
  return _internal_xla_unsupported_crash_on_hlo_pass_noop_change();
}
inline void DebugOptions::set_xla_unsupported_crash_on_hlo_pass_noop_change(bool value) {
  _internal_set_xla_unsupported_crash_on_hlo_pass_noop_change(value);
  _impl_._has_bits_[6] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_noop_change)
}
inline bool DebugOptions::_internal_xla_unsupported_crash_on_hlo_pass_noop_change() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_unsupported_crash_on_hlo_pass_noop_change_;
}
inline void DebugOptions::_internal_set_xla_unsupported_crash_on_hlo_pass_noop_change(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_noop_change_ = value;
}

// optional bool xla_unsupported_crash_on_hlo_pass_silent_hlo_change = 380;
inline bool DebugOptions::has_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const {
  bool value = (_impl_._has_bits_[6] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_silent_hlo_change_ = false;
  _impl_._has_bits_[6] &= ~0x20000000u;
}
inline bool DebugOptions::xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_silent_hlo_change)
  return _internal_xla_unsupported_crash_on_hlo_pass_silent_hlo_change();
}
inline void DebugOptions::set_xla_unsupported_crash_on_hlo_pass_silent_hlo_change(bool value) {
  _internal_set_xla_unsupported_crash_on_hlo_pass_silent_hlo_change(value);
  _impl_._has_bits_[6] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_silent_hlo_change)
}
inline bool DebugOptions::_internal_xla_unsupported_crash_on_hlo_pass_silent_hlo_change() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_unsupported_crash_on_hlo_pass_silent_hlo_change_;
}
inline void DebugOptions::_internal_set_xla_unsupported_crash_on_hlo_pass_silent_hlo_change(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_unsupported_crash_on_hlo_pass_silent_hlo_change_ = value;
}

// optional .xla.DebugOptions.XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode = 365;
inline bool DebugOptions::has_xla_cpu_experimental_xnn_graph_fusion_mode() const {
  bool value = (_impl_._has_bits_[6] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_experimental_xnn_graph_fusion_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_experimental_xnn_graph_fusion_mode_ = 0;
  _impl_._has_bits_[6] &= ~0x00200000u;
}
inline ::xla::DebugOptions_XnnGraphFusionMode DebugOptions::xla_cpu_experimental_xnn_graph_fusion_mode() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_experimental_xnn_graph_fusion_mode)
  return _internal_xla_cpu_experimental_xnn_graph_fusion_mode();
}
inline void DebugOptions::set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value) {
  _internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(value);
  _impl_._has_bits_[6] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_experimental_xnn_graph_fusion_mode)
}
inline ::xla::DebugOptions_XnnGraphFusionMode DebugOptions::_internal_xla_cpu_experimental_xnn_graph_fusion_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_XnnGraphFusionMode>(_impl_.xla_cpu_experimental_xnn_graph_fusion_mode_);
}
inline void DebugOptions::_internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_experimental_xnn_graph_fusion_mode_ = value;
}

// optional bool xla_cpu_copy_insertion_use_region_analysis = 337;
inline bool DebugOptions::has_xla_cpu_copy_insertion_use_region_analysis() const {
  bool value = (_impl_._has_bits_[3] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_copy_insertion_use_region_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_copy_insertion_use_region_analysis_ = false;
  _impl_._has_bits_[3] &= ~0x00000080u;
}
inline bool DebugOptions::xla_cpu_copy_insertion_use_region_analysis() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_copy_insertion_use_region_analysis)
  return _internal_xla_cpu_copy_insertion_use_region_analysis();
}
inline void DebugOptions::set_xla_cpu_copy_insertion_use_region_analysis(bool value) {
  _internal_set_xla_cpu_copy_insertion_use_region_analysis(value);
  _impl_._has_bits_[3] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_copy_insertion_use_region_analysis)
}
inline bool DebugOptions::_internal_xla_cpu_copy_insertion_use_region_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_copy_insertion_use_region_analysis_;
}
inline void DebugOptions::_internal_set_xla_cpu_copy_insertion_use_region_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_copy_insertion_use_region_analysis_ = value;
}

// optional int32 xla_cpu_emitter_verification_level = 395;
inline bool DebugOptions::has_xla_cpu_emitter_verification_level() const {
  bool value = (_impl_._has_bits_[7] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_emitter_verification_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_emitter_verification_level_ = 0;
  _impl_._has_bits_[7] &= ~0x00000010u;
}
inline ::int32_t DebugOptions::xla_cpu_emitter_verification_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_emitter_verification_level)
  return _internal_xla_cpu_emitter_verification_level();
}
inline void DebugOptions::set_xla_cpu_emitter_verification_level(::int32_t value) {
  _internal_set_xla_cpu_emitter_verification_level(value);
  _impl_._has_bits_[7] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_emitter_verification_level)
}
inline ::int32_t DebugOptions::_internal_xla_cpu_emitter_verification_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_emitter_verification_level_;
}
inline void DebugOptions::_internal_set_xla_cpu_emitter_verification_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_emitter_verification_level_ = value;
}

// optional bool xla_cpu_enable_concurrency_optimized_scheduler = 307;
inline bool DebugOptions::has_xla_cpu_enable_concurrency_optimized_scheduler() const {
  bool value = (_impl_._has_bits_[3] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_enable_concurrency_optimized_scheduler() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_concurrency_optimized_scheduler_ = false;
  _impl_._has_bits_[3] &= ~0x00000100u;
}
inline bool DebugOptions::xla_cpu_enable_concurrency_optimized_scheduler() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_concurrency_optimized_scheduler)
  return _internal_xla_cpu_enable_concurrency_optimized_scheduler();
}
inline void DebugOptions::set_xla_cpu_enable_concurrency_optimized_scheduler(bool value) {
  _internal_set_xla_cpu_enable_concurrency_optimized_scheduler(value);
  _impl_._has_bits_[3] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_concurrency_optimized_scheduler)
}
inline bool DebugOptions::_internal_xla_cpu_enable_concurrency_optimized_scheduler() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_enable_concurrency_optimized_scheduler_;
}
inline void DebugOptions::_internal_set_xla_cpu_enable_concurrency_optimized_scheduler(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_concurrency_optimized_scheduler_ = value;
}

// optional bool xla_cpu_enable_fast_math = 99;
inline bool DebugOptions::has_xla_cpu_enable_fast_math() const {
  bool value = (_impl_._has_bits_[3] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_enable_fast_math() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_fast_math_ = false;
  _impl_._has_bits_[3] &= ~0x00000200u;
}
inline bool DebugOptions::xla_cpu_enable_fast_math() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_fast_math)
  return _internal_xla_cpu_enable_fast_math();
}
inline void DebugOptions::set_xla_cpu_enable_fast_math(bool value) {
  _internal_set_xla_cpu_enable_fast_math(value);
  _impl_._has_bits_[3] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_fast_math)
}
inline bool DebugOptions::_internal_xla_cpu_enable_fast_math() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_enable_fast_math_;
}
inline void DebugOptions::_internal_set_xla_cpu_enable_fast_math(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_fast_math_ = value;
}

// optional bool xla_cpu_enable_fast_min_max = 140;
inline bool DebugOptions::has_xla_cpu_enable_fast_min_max() const {
  bool value = (_impl_._has_bits_[3] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_enable_fast_min_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_fast_min_max_ = false;
  _impl_._has_bits_[3] &= ~0x00000400u;
}
inline bool DebugOptions::xla_cpu_enable_fast_min_max() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_fast_min_max)
  return _internal_xla_cpu_enable_fast_min_max();
}
inline void DebugOptions::set_xla_cpu_enable_fast_min_max(bool value) {
  _internal_set_xla_cpu_enable_fast_min_max(value);
  _impl_._has_bits_[3] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_fast_min_max)
}
inline bool DebugOptions::_internal_xla_cpu_enable_fast_min_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_enable_fast_min_max_;
}
inline void DebugOptions::_internal_set_xla_cpu_enable_fast_min_max(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_fast_min_max_ = value;
}

// optional bool xla_cpu_fast_math_honor_division = 126;
inline bool DebugOptions::has_xla_cpu_fast_math_honor_division() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_fast_math_honor_division() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_division_ = false;
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline bool DebugOptions::xla_cpu_fast_math_honor_division() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_division)
  return _internal_xla_cpu_fast_math_honor_division();
}
inline void DebugOptions::set_xla_cpu_fast_math_honor_division(bool value) {
  _internal_set_xla_cpu_fast_math_honor_division(value);
  _impl_._has_bits_[1] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_division)
}
inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_division() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_fast_math_honor_division_;
}
inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_division(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_division_ = value;
}

// optional bool xla_cpu_fast_math_honor_functions = 129;
inline bool DebugOptions::has_xla_cpu_fast_math_honor_functions() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_fast_math_honor_functions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_functions_ = false;
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline bool DebugOptions::xla_cpu_fast_math_honor_functions() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_functions)
  return _internal_xla_cpu_fast_math_honor_functions();
}
inline void DebugOptions::set_xla_cpu_fast_math_honor_functions(bool value) {
  _internal_set_xla_cpu_fast_math_honor_functions(value);
  _impl_._has_bits_[1] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_functions)
}
inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_functions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_fast_math_honor_functions_;
}
inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_functions(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_functions_ = value;
}

// optional bool xla_cpu_fast_math_honor_infs = 121;
inline bool DebugOptions::has_xla_cpu_fast_math_honor_infs() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_fast_math_honor_infs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_infs_ = false;
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline bool DebugOptions::xla_cpu_fast_math_honor_infs() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_infs)
  return _internal_xla_cpu_fast_math_honor_infs();
}
inline void DebugOptions::set_xla_cpu_fast_math_honor_infs(bool value) {
  _internal_set_xla_cpu_fast_math_honor_infs(value);
  _impl_._has_bits_[1] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_infs)
}
inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_infs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_fast_math_honor_infs_;
}
inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_infs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_infs_ = value;
}

// optional bool xla_cpu_fast_math_honor_nans = 120;
inline bool DebugOptions::has_xla_cpu_fast_math_honor_nans() const {
  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_fast_math_honor_nans() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_nans_ = false;
  _impl_._has_bits_[1] &= ~0x00002000u;
}
inline bool DebugOptions::xla_cpu_fast_math_honor_nans() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_nans)
  return _internal_xla_cpu_fast_math_honor_nans();
}
inline void DebugOptions::set_xla_cpu_fast_math_honor_nans(bool value) {
  _internal_set_xla_cpu_fast_math_honor_nans(value);
  _impl_._has_bits_[1] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_nans)
}
inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_nans() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_fast_math_honor_nans_;
}
inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_nans(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_fast_math_honor_nans_ = value;
}

// optional bool xla_cpu_generate_unique_c_style_kernel_entry_points = 372;
inline bool DebugOptions::has_xla_cpu_generate_unique_c_style_kernel_entry_points() const {
  bool value = (_impl_._has_bits_[6] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_generate_unique_c_style_kernel_entry_points() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_generate_unique_c_style_kernel_entry_points_ = false;
  _impl_._has_bits_[6] &= ~0x00000002u;
}
inline bool DebugOptions::xla_cpu_generate_unique_c_style_kernel_entry_points() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_generate_unique_c_style_kernel_entry_points)
  return _internal_xla_cpu_generate_unique_c_style_kernel_entry_points();
}
inline void DebugOptions::set_xla_cpu_generate_unique_c_style_kernel_entry_points(bool value) {
  _internal_set_xla_cpu_generate_unique_c_style_kernel_entry_points(value);
  _impl_._has_bits_[6] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_generate_unique_c_style_kernel_entry_points)
}
inline bool DebugOptions::_internal_xla_cpu_generate_unique_c_style_kernel_entry_points() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_generate_unique_c_style_kernel_entry_points_;
}
inline void DebugOptions::_internal_set_xla_cpu_generate_unique_c_style_kernel_entry_points(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_generate_unique_c_style_kernel_entry_points_ = value;
}

// optional string xla_cpu_max_isa = 333;
inline bool DebugOptions::has_xla_cpu_max_isa() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_max_isa() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_max_isa_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const std::string& DebugOptions::xla_cpu_max_isa() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_max_isa)
  return _internal_xla_cpu_max_isa();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_cpu_max_isa(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.xla_cpu_max_isa_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_max_isa)
}
inline std::string* DebugOptions::mutable_xla_cpu_max_isa() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_cpu_max_isa();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_cpu_max_isa)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_cpu_max_isa() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_max_isa_.Get();
}
inline void DebugOptions::_internal_set_xla_cpu_max_isa(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.xla_cpu_max_isa_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_cpu_max_isa() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00008000u;
  return _impl_.xla_cpu_max_isa_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_cpu_max_isa() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_cpu_max_isa)
  if ((_impl_._has_bits_[0] & 0x00008000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00008000u;
  auto* released = _impl_.xla_cpu_max_isa_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_cpu_max_isa_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_cpu_max_isa(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.xla_cpu_max_isa_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_cpu_max_isa_.IsDefault()) {
          _impl_.xla_cpu_max_isa_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_cpu_max_isa)
}

// optional int32 xla_cpu_parallel_codegen_split_count = 323;
inline bool DebugOptions::has_xla_cpu_parallel_codegen_split_count() const {
  bool value = (_impl_._has_bits_[5] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_parallel_codegen_split_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_parallel_codegen_split_count_ = 0;
  _impl_._has_bits_[5] &= ~0x00000800u;
}
inline ::int32_t DebugOptions::xla_cpu_parallel_codegen_split_count() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_parallel_codegen_split_count)
  return _internal_xla_cpu_parallel_codegen_split_count();
}
inline void DebugOptions::set_xla_cpu_parallel_codegen_split_count(::int32_t value) {
  _internal_set_xla_cpu_parallel_codegen_split_count(value);
  _impl_._has_bits_[5] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_parallel_codegen_split_count)
}
inline ::int32_t DebugOptions::_internal_xla_cpu_parallel_codegen_split_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_parallel_codegen_split_count_;
}
inline void DebugOptions::_internal_set_xla_cpu_parallel_codegen_split_count(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_parallel_codegen_split_count_ = value;
}

// optional int32 xla_cpu_prefer_vector_width = 308;
inline bool DebugOptions::has_xla_cpu_prefer_vector_width() const {
  bool value = (_impl_._has_bits_[5] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_prefer_vector_width() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_prefer_vector_width_ = 0;
  _impl_._has_bits_[5] &= ~0x00000010u;
}
inline ::int32_t DebugOptions::xla_cpu_prefer_vector_width() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_prefer_vector_width)
  return _internal_xla_cpu_prefer_vector_width();
}
inline void DebugOptions::set_xla_cpu_prefer_vector_width(::int32_t value) {
  _internal_set_xla_cpu_prefer_vector_width(value);
  _impl_._has_bits_[5] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_prefer_vector_width)
}
inline ::int32_t DebugOptions::_internal_xla_cpu_prefer_vector_width() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_prefer_vector_width_;
}
inline void DebugOptions::_internal_set_xla_cpu_prefer_vector_width(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_prefer_vector_width_ = value;
}

// optional bool xla_cpu_use_fusion_emitters = 376;
inline bool DebugOptions::has_xla_cpu_use_fusion_emitters() const {
  bool value = (_impl_._has_bits_[6] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_use_fusion_emitters() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_fusion_emitters_ = false;
  _impl_._has_bits_[6] &= ~0x00000004u;
}
inline bool DebugOptions::xla_cpu_use_fusion_emitters() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_fusion_emitters)
  return _internal_xla_cpu_use_fusion_emitters();
}
inline void DebugOptions::set_xla_cpu_use_fusion_emitters(bool value) {
  _internal_set_xla_cpu_use_fusion_emitters(value);
  _impl_._has_bits_[6] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_fusion_emitters)
}
inline bool DebugOptions::_internal_xla_cpu_use_fusion_emitters() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_use_fusion_emitters_;
}
inline void DebugOptions::_internal_set_xla_cpu_use_fusion_emitters(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_fusion_emitters_ = value;
}

// optional bool xla_cpu_use_thunk_runtime = 298;
inline bool DebugOptions::has_xla_cpu_use_thunk_runtime() const {
  bool value = (_impl_._has_bits_[6] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_use_thunk_runtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_thunk_runtime_ = false;
  _impl_._has_bits_[6] &= ~0x00000008u;
}
inline bool DebugOptions::xla_cpu_use_thunk_runtime() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_thunk_runtime)
  return _internal_xla_cpu_use_thunk_runtime();
}
inline void DebugOptions::set_xla_cpu_use_thunk_runtime(bool value) {
  _internal_set_xla_cpu_use_thunk_runtime(value);
  _impl_._has_bits_[6] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_thunk_runtime)
}
inline bool DebugOptions::_internal_xla_cpu_use_thunk_runtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_use_thunk_runtime_;
}
inline void DebugOptions::_internal_set_xla_cpu_use_thunk_runtime(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_thunk_runtime_ = value;
}

// optional bool xla_cpu_use_xnnpack = 359;
inline bool DebugOptions::has_xla_cpu_use_xnnpack() const {
  bool value = (_impl_._has_bits_[6] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_use_xnnpack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_xnnpack_ = false;
  _impl_._has_bits_[6] &= ~0x00000010u;
}
inline bool DebugOptions::xla_cpu_use_xnnpack() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_xnnpack)
  return _internal_xla_cpu_use_xnnpack();
}
inline void DebugOptions::set_xla_cpu_use_xnnpack(bool value) {
  _internal_set_xla_cpu_use_xnnpack(value);
  _impl_._has_bits_[6] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_xnnpack)
}
inline bool DebugOptions::_internal_xla_cpu_use_xnnpack() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_use_xnnpack_;
}
inline void DebugOptions::_internal_set_xla_cpu_use_xnnpack(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_xnnpack_ = value;
}

// optional bool xla_enable_fast_math = 335;
inline bool DebugOptions::has_xla_enable_fast_math() const {
  bool value = (_impl_._has_bits_[5] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_enable_fast_math() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_fast_math_ = false;
  _impl_._has_bits_[5] &= ~0x00000020u;
}
inline bool DebugOptions::xla_enable_fast_math() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_fast_math)
  return _internal_xla_enable_fast_math();
}
inline void DebugOptions::set_xla_enable_fast_math(bool value) {
  _internal_set_xla_enable_fast_math(value);
  _impl_._has_bits_[5] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_fast_math)
}
inline bool DebugOptions::_internal_xla_enable_fast_math() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_enable_fast_math_;
}
inline void DebugOptions::_internal_set_xla_enable_fast_math(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_fast_math_ = value;
}

// optional string xla_gpu_algorithm_denylist_path = 128;
inline bool DebugOptions::has_xla_gpu_algorithm_denylist_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_algorithm_denylist_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_algorithm_denylist_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& DebugOptions::xla_gpu_algorithm_denylist_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_algorithm_denylist_path)
  return _internal_xla_gpu_algorithm_denylist_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_algorithm_denylist_path(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.xla_gpu_algorithm_denylist_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_algorithm_denylist_path)
}
inline std::string* DebugOptions::mutable_xla_gpu_algorithm_denylist_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_algorithm_denylist_path();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_algorithm_denylist_path)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_algorithm_denylist_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_algorithm_denylist_path_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_algorithm_denylist_path(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.xla_gpu_algorithm_denylist_path_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_algorithm_denylist_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.xla_gpu_algorithm_denylist_path_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_algorithm_denylist_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_algorithm_denylist_path)
  if ((_impl_._has_bits_[0] & 0x00000010u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* released = _impl_.xla_gpu_algorithm_denylist_path_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_algorithm_denylist_path_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_algorithm_denylist_path(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.xla_gpu_algorithm_denylist_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_algorithm_denylist_path_.IsDefault()) {
          _impl_.xla_gpu_algorithm_denylist_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_algorithm_denylist_path)
}

// optional int64 xla_gpu_all_gather_combine_threshold_bytes = 212;
inline bool DebugOptions::has_xla_gpu_all_gather_combine_threshold_bytes() const {
  bool value = (_impl_._has_bits_[2] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_all_gather_combine_threshold_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_gather_combine_threshold_bytes_ = ::int64_t{0};
  _impl_._has_bits_[2] &= ~0x02000000u;
}
inline ::int64_t DebugOptions::xla_gpu_all_gather_combine_threshold_bytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_gather_combine_threshold_bytes)
  return _internal_xla_gpu_all_gather_combine_threshold_bytes();
}
inline void DebugOptions::set_xla_gpu_all_gather_combine_threshold_bytes(::int64_t value) {
  _internal_set_xla_gpu_all_gather_combine_threshold_bytes(value);
  _impl_._has_bits_[2] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_gather_combine_threshold_bytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_all_gather_combine_threshold_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_all_gather_combine_threshold_bytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_all_gather_combine_threshold_bytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_gather_combine_threshold_bytes_ = value;
}

// optional int32 xla_gpu_all_reduce_blueconnect_num_devices_per_host = 159;
inline bool DebugOptions::has_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const {
  bool value = (_impl_._has_bits_[1] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_all_reduce_blueconnect_num_devices_per_host() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_ = 0;
  _impl_._has_bits_[1] &= ~0x02000000u;
}
inline ::int32_t DebugOptions::xla_gpu_all_reduce_blueconnect_num_devices_per_host() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_reduce_blueconnect_num_devices_per_host)
  return _internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host();
}
inline void DebugOptions::set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(::int32_t value) {
  _internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(value);
  _impl_._has_bits_[1] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_reduce_blueconnect_num_devices_per_host)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_;
}
inline void DebugOptions::_internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_ = value;
}

// optional int64 xla_gpu_all_reduce_combine_threshold_bytes = 157;
inline bool DebugOptions::has_xla_gpu_all_reduce_combine_threshold_bytes() const {
  bool value = (_impl_._has_bits_[1] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_all_reduce_combine_threshold_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_reduce_combine_threshold_bytes_ = ::int64_t{0};
  _impl_._has_bits_[1] &= ~0x04000000u;
}
inline ::int64_t DebugOptions::xla_gpu_all_reduce_combine_threshold_bytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_reduce_combine_threshold_bytes)
  return _internal_xla_gpu_all_reduce_combine_threshold_bytes();
}
inline void DebugOptions::set_xla_gpu_all_reduce_combine_threshold_bytes(::int64_t value) {
  _internal_set_xla_gpu_all_reduce_combine_threshold_bytes(value);
  _impl_._has_bits_[1] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_reduce_combine_threshold_bytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_all_reduce_combine_threshold_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_all_reduce_combine_threshold_bytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_all_reduce_combine_threshold_bytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_all_reduce_combine_threshold_bytes_ = value;
}

// map<string, string> xla_gpu_analytical_latency_estimator_options = 357;
inline int DebugOptions::_internal_xla_gpu_analytical_latency_estimator_options_size() const {
  return _internal_xla_gpu_analytical_latency_estimator_options().size();
}
inline int DebugOptions::xla_gpu_analytical_latency_estimator_options_size() const {
  return _internal_xla_gpu_analytical_latency_estimator_options_size();
}
inline void DebugOptions::clear_xla_gpu_analytical_latency_estimator_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_analytical_latency_estimator_options_.Clear();
}
inline const ::google::protobuf::Map<std::string, std::string>& DebugOptions::_internal_xla_gpu_analytical_latency_estimator_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_analytical_latency_estimator_options_.GetMap();
}
inline const ::google::protobuf::Map<std::string, std::string>& DebugOptions::xla_gpu_analytical_latency_estimator_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:xla.DebugOptions.xla_gpu_analytical_latency_estimator_options)
  return _internal_xla_gpu_analytical_latency_estimator_options();
}
inline ::google::protobuf::Map<std::string, std::string>* DebugOptions::_internal_mutable_xla_gpu_analytical_latency_estimator_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.xla_gpu_analytical_latency_estimator_options_.MutableMap();
}
inline ::google::protobuf::Map<std::string, std::string>* DebugOptions::mutable_xla_gpu_analytical_latency_estimator_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:xla.DebugOptions.xla_gpu_analytical_latency_estimator_options)
  return _internal_mutable_xla_gpu_analytical_latency_estimator_options();
}

// optional bool xla_gpu_async_dot = 321;
inline bool DebugOptions::has_xla_gpu_async_dot() const {
  bool value = (_impl_._has_bits_[5] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_async_dot() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_async_dot_ = false;
  _impl_._has_bits_[5] &= ~0x00000040u;
}
inline bool DebugOptions::xla_gpu_async_dot() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_async_dot)
  return _internal_xla_gpu_async_dot();
}
inline void DebugOptions::set_xla_gpu_async_dot(bool value) {
  _internal_set_xla_gpu_async_dot(value);
  _impl_._has_bits_[5] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_async_dot)
}
inline bool DebugOptions::_internal_xla_gpu_async_dot() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_async_dot_;
}
inline void DebugOptions::_internal_set_xla_gpu_async_dot(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_async_dot_ = value;
}

// optional int32 xla_gpu_auto_spmd_partitioning_memory_budget_gb = 224;
inline bool DebugOptions::has_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const {
  bool value = (_impl_._has_bits_[3] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_auto_spmd_partitioning_memory_budget_gb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_ = 0;
  _impl_._has_bits_[3] &= ~0x00000800u;
}
inline ::int32_t DebugOptions::xla_gpu_auto_spmd_partitioning_memory_budget_gb() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_gb)
  return _internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb();
}
inline void DebugOptions::set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(::int32_t value) {
  _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(value);
  _impl_._has_bits_[3] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_gb)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_;
}
inline void DebugOptions::_internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_ = value;
}

// optional float xla_gpu_auto_spmd_partitioning_memory_budget_ratio = 225;
inline bool DebugOptions::has_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const {
  bool value = (_impl_._has_bits_[3] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_ = 0;
  _impl_._has_bits_[3] &= ~0x00001000u;
}
inline float DebugOptions::xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_ratio)
  return _internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio();
}
inline void DebugOptions::set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value) {
  _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(value);
  _impl_._has_bits_[3] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_ratio)
}
inline float DebugOptions::_internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_;
}
inline void DebugOptions::_internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_ = value;
}

// optional float xla_gpu_autotune_gemm_rtol = 316;
inline bool DebugOptions::has_xla_gpu_autotune_gemm_rtol() const {
  bool value = (_impl_._has_bits_[5] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_autotune_gemm_rtol() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_gemm_rtol_ = 0;
  _impl_._has_bits_[5] &= ~0x00000200u;
}
inline float DebugOptions::xla_gpu_autotune_gemm_rtol() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_gemm_rtol)
  return _internal_xla_gpu_autotune_gemm_rtol();
}
inline void DebugOptions::set_xla_gpu_autotune_gemm_rtol(float value) {
  _internal_set_xla_gpu_autotune_gemm_rtol(value);
  _impl_._has_bits_[5] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_gemm_rtol)
}
inline float DebugOptions::_internal_xla_gpu_autotune_gemm_rtol() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_autotune_gemm_rtol_;
}
inline void DebugOptions::_internal_set_xla_gpu_autotune_gemm_rtol(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_gemm_rtol_ = value;
}

// optional int32 xla_gpu_autotune_level = 123;
inline bool DebugOptions::has_xla_gpu_autotune_level() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_autotune_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_level_ = 0;
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline ::int32_t DebugOptions::xla_gpu_autotune_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_level)
  return _internal_xla_gpu_autotune_level();
}
inline void DebugOptions::set_xla_gpu_autotune_level(::int32_t value) {
  _internal_set_xla_gpu_autotune_level(value);
  _impl_._has_bits_[1] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_level)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_autotune_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_autotune_level_;
}
inline void DebugOptions::_internal_set_xla_gpu_autotune_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_level_ = value;
}

// optional int64 xla_gpu_autotune_max_solutions = 288;
inline bool DebugOptions::has_xla_gpu_autotune_max_solutions() const {
  bool value = (_impl_._has_bits_[4] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_autotune_max_solutions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_max_solutions_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00800000u;
}
inline ::int64_t DebugOptions::xla_gpu_autotune_max_solutions() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_max_solutions)
  return _internal_xla_gpu_autotune_max_solutions();
}
inline void DebugOptions::set_xla_gpu_autotune_max_solutions(::int64_t value) {
  _internal_set_xla_gpu_autotune_max_solutions(value);
  _impl_._has_bits_[4] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_max_solutions)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_autotune_max_solutions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_autotune_max_solutions_;
}
inline void DebugOptions::_internal_set_xla_gpu_autotune_max_solutions(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_autotune_max_solutions_ = value;
}

// optional bool xla_gpu_collect_cost_model_stats = 240;
inline bool DebugOptions::has_xla_gpu_collect_cost_model_stats() const {
  bool value = (_impl_._has_bits_[5] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_collect_cost_model_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collect_cost_model_stats_ = false;
  _impl_._has_bits_[5] &= ~0x00000080u;
}
inline bool DebugOptions::xla_gpu_collect_cost_model_stats() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collect_cost_model_stats)
  return _internal_xla_gpu_collect_cost_model_stats();
}
inline void DebugOptions::set_xla_gpu_collect_cost_model_stats(bool value) {
  _internal_set_xla_gpu_collect_cost_model_stats(value);
  _impl_._has_bits_[5] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collect_cost_model_stats)
}
inline bool DebugOptions::_internal_xla_gpu_collect_cost_model_stats() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_collect_cost_model_stats_;
}
inline void DebugOptions::_internal_set_xla_gpu_collect_cost_model_stats(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collect_cost_model_stats_ = value;
}

// optional int32 xla_gpu_collective_inflation_factor = 205;
inline bool DebugOptions::has_xla_gpu_collective_inflation_factor() const {
  bool value = (_impl_._has_bits_[2] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_collective_inflation_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_inflation_factor_ = 0;
  _impl_._has_bits_[2] &= ~0x00080000u;
}
inline ::int32_t DebugOptions::xla_gpu_collective_inflation_factor() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collective_inflation_factor)
  return _internal_xla_gpu_collective_inflation_factor();
}
inline void DebugOptions::set_xla_gpu_collective_inflation_factor(::int32_t value) {
  _internal_set_xla_gpu_collective_inflation_factor(value);
  _impl_._has_bits_[2] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collective_inflation_factor)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_collective_inflation_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_collective_inflation_factor_;
}
inline void DebugOptions::_internal_set_xla_gpu_collective_inflation_factor(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_inflation_factor_ = value;
}

// optional int64 xla_gpu_collective_permute_combine_threshold_bytes = 378;
inline bool DebugOptions::has_xla_gpu_collective_permute_combine_threshold_bytes() const {
  bool value = (_impl_._has_bits_[6] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_collective_permute_combine_threshold_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_permute_combine_threshold_bytes_ = ::int64_t{0};
  _impl_._has_bits_[6] &= ~0x80000000u;
}
inline ::int64_t DebugOptions::xla_gpu_collective_permute_combine_threshold_bytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collective_permute_combine_threshold_bytes)
  return _internal_xla_gpu_collective_permute_combine_threshold_bytes();
}
inline void DebugOptions::set_xla_gpu_collective_permute_combine_threshold_bytes(::int64_t value) {
  _internal_set_xla_gpu_collective_permute_combine_threshold_bytes(value);
  _impl_._has_bits_[6] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collective_permute_combine_threshold_bytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_collective_permute_combine_threshold_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_collective_permute_combine_threshold_bytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_collective_permute_combine_threshold_bytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_permute_combine_threshold_bytes_ = value;
}

// optional int64 xla_gpu_collective_permute_decomposer_threshold = 237;
inline bool DebugOptions::has_xla_gpu_collective_permute_decomposer_threshold() const {
  bool value = (_impl_._has_bits_[3] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_collective_permute_decomposer_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_permute_decomposer_threshold_ = ::int64_t{0};
  _impl_._has_bits_[3] &= ~0x00400000u;
}
inline ::int64_t DebugOptions::xla_gpu_collective_permute_decomposer_threshold() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collective_permute_decomposer_threshold)
  return _internal_xla_gpu_collective_permute_decomposer_threshold();
}
inline void DebugOptions::set_xla_gpu_collective_permute_decomposer_threshold(::int64_t value) {
  _internal_set_xla_gpu_collective_permute_decomposer_threshold(value);
  _impl_._has_bits_[3] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collective_permute_decomposer_threshold)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_collective_permute_decomposer_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_collective_permute_decomposer_threshold_;
}
inline void DebugOptions::_internal_set_xla_gpu_collective_permute_decomposer_threshold(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collective_permute_decomposer_threshold_ = value;
}

// optional bool xla_gpu_collectives_use_persistent_cliques = 354;
inline bool DebugOptions::has_xla_gpu_collectives_use_persistent_cliques() const {
  bool value = (_impl_._has_bits_[5] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_collectives_use_persistent_cliques() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collectives_use_persistent_cliques_ = false;
  _impl_._has_bits_[5] &= ~0x00000100u;
}
inline bool DebugOptions::xla_gpu_collectives_use_persistent_cliques() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collectives_use_persistent_cliques)
  return _internal_xla_gpu_collectives_use_persistent_cliques();
}
inline void DebugOptions::set_xla_gpu_collectives_use_persistent_cliques(bool value) {
  _internal_set_xla_gpu_collectives_use_persistent_cliques(value);
  _impl_._has_bits_[5] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collectives_use_persistent_cliques)
}
inline bool DebugOptions::_internal_xla_gpu_collectives_use_persistent_cliques() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_collectives_use_persistent_cliques_;
}
inline void DebugOptions::_internal_set_xla_gpu_collectives_use_persistent_cliques(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_collectives_use_persistent_cliques_ = value;
}

// optional bool xla_gpu_copy_insertion_use_region_analysis = 236;
inline bool DebugOptions::has_xla_gpu_copy_insertion_use_region_analysis() const {
  bool value = (_impl_._has_bits_[2] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_copy_insertion_use_region_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_copy_insertion_use_region_analysis_ = false;
  _impl_._has_bits_[2] &= ~0x00000400u;
}
inline bool DebugOptions::xla_gpu_copy_insertion_use_region_analysis() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_copy_insertion_use_region_analysis)
  return _internal_xla_gpu_copy_insertion_use_region_analysis();
}
inline void DebugOptions::set_xla_gpu_copy_insertion_use_region_analysis(bool value) {
  _internal_set_xla_gpu_copy_insertion_use_region_analysis(value);
  _impl_._has_bits_[2] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_copy_insertion_use_region_analysis)
}
inline bool DebugOptions::_internal_xla_gpu_copy_insertion_use_region_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_copy_insertion_use_region_analysis_;
}
inline void DebugOptions::_internal_set_xla_gpu_copy_insertion_use_region_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_copy_insertion_use_region_analysis_ = value;
}

// optional bool xla_gpu_crash_on_verification_failures = 101;
inline bool DebugOptions::has_xla_gpu_crash_on_verification_failures() const {
  bool value = (_impl_._has_bits_[2] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_crash_on_verification_failures() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_crash_on_verification_failures_ = false;
  _impl_._has_bits_[2] &= ~0x00000800u;
}
inline bool DebugOptions::xla_gpu_crash_on_verification_failures() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_crash_on_verification_failures)
  return _internal_xla_gpu_crash_on_verification_failures();
}
inline void DebugOptions::set_xla_gpu_crash_on_verification_failures(bool value) {
  _internal_set_xla_gpu_crash_on_verification_failures(value);
  _impl_._has_bits_[2] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_crash_on_verification_failures)
}
inline bool DebugOptions::_internal_xla_gpu_crash_on_verification_failures() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_crash_on_verification_failures_;
}
inline void DebugOptions::_internal_set_xla_gpu_crash_on_verification_failures(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_crash_on_verification_failures_ = value;
}

// optional bool xla_gpu_cublas_fallback = 247;
inline bool DebugOptions::has_xla_gpu_cublas_fallback() const {
  bool value = (_impl_._has_bits_[2] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_cublas_fallback() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cublas_fallback_ = false;
  _impl_._has_bits_[2] &= ~0x00001000u;
}
inline bool DebugOptions::xla_gpu_cublas_fallback() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cublas_fallback)
  return _internal_xla_gpu_cublas_fallback();
}
inline void DebugOptions::set_xla_gpu_cublas_fallback(bool value) {
  _internal_set_xla_gpu_cublas_fallback(value);
  _impl_._has_bits_[2] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cublas_fallback)
}
inline bool DebugOptions::_internal_xla_gpu_cublas_fallback() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_cublas_fallback_;
}
inline void DebugOptions::_internal_set_xla_gpu_cublas_fallback(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cublas_fallback_ = value;
}

// optional string xla_gpu_cuda_data_dir = 61;
inline bool DebugOptions::has_xla_gpu_cuda_data_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_cuda_data_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cuda_data_dir_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DebugOptions::xla_gpu_cuda_data_dir() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cuda_data_dir)
  return _internal_xla_gpu_cuda_data_dir();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_cuda_data_dir(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.xla_gpu_cuda_data_dir_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cuda_data_dir)
}
inline std::string* DebugOptions::mutable_xla_gpu_cuda_data_dir() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_cuda_data_dir();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_cuda_data_dir)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_cuda_data_dir() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_cuda_data_dir_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_cuda_data_dir(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.xla_gpu_cuda_data_dir_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_cuda_data_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.xla_gpu_cuda_data_dir_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_cuda_data_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_cuda_data_dir)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.xla_gpu_cuda_data_dir_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_cuda_data_dir_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_cuda_data_dir(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.xla_gpu_cuda_data_dir_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_cuda_data_dir_.IsDefault()) {
          _impl_.xla_gpu_cuda_data_dir_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_cuda_data_dir)
}

// optional int32 xla_gpu_cudnn_gemm_fusion_level = 285;
inline bool DebugOptions::has_xla_gpu_cudnn_gemm_fusion_level() const {
  bool value = (_impl_._has_bits_[4] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_cudnn_gemm_fusion_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cudnn_gemm_fusion_level_ = 0;
  _impl_._has_bits_[4] &= ~0x01000000u;
}
inline ::int32_t DebugOptions::xla_gpu_cudnn_gemm_fusion_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cudnn_gemm_fusion_level)
  return _internal_xla_gpu_cudnn_gemm_fusion_level();
}
inline void DebugOptions::set_xla_gpu_cudnn_gemm_fusion_level(::int32_t value) {
  _internal_set_xla_gpu_cudnn_gemm_fusion_level(value);
  _impl_._has_bits_[4] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cudnn_gemm_fusion_level)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_cudnn_gemm_fusion_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_cudnn_gemm_fusion_level_;
}
inline void DebugOptions::_internal_set_xla_gpu_cudnn_gemm_fusion_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cudnn_gemm_fusion_level_ = value;
}

// optional int32 xla_gpu_cudnn_gemm_max_plans = 318;
inline bool DebugOptions::has_xla_gpu_cudnn_gemm_max_plans() const {
  bool value = (_impl_._has_bits_[5] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_cudnn_gemm_max_plans() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cudnn_gemm_max_plans_ = 0;
  _impl_._has_bits_[5] &= ~0x00000400u;
}
inline ::int32_t DebugOptions::xla_gpu_cudnn_gemm_max_plans() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cudnn_gemm_max_plans)
  return _internal_xla_gpu_cudnn_gemm_max_plans();
}
inline void DebugOptions::set_xla_gpu_cudnn_gemm_max_plans(::int32_t value) {
  _internal_set_xla_gpu_cudnn_gemm_max_plans(value);
  _impl_._has_bits_[5] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cudnn_gemm_max_plans)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_cudnn_gemm_max_plans() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_cudnn_gemm_max_plans_;
}
inline void DebugOptions::_internal_set_xla_gpu_cudnn_gemm_max_plans(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_cudnn_gemm_max_plans_ = value;
}

// optional bool xla_gpu_deterministic_ops = 148;
inline bool DebugOptions::has_xla_gpu_deterministic_ops() const {
  bool value = (_impl_._has_bits_[2] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_deterministic_ops() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_deterministic_ops_ = false;
  _impl_._has_bits_[2] &= ~0x00002000u;
}
inline bool DebugOptions::xla_gpu_deterministic_ops() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_deterministic_ops)
  return _internal_xla_gpu_deterministic_ops();
}
inline void DebugOptions::set_xla_gpu_deterministic_ops(bool value) {
  _internal_set_xla_gpu_deterministic_ops(value);
  _impl_._has_bits_[2] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_deterministic_ops)
}
inline bool DebugOptions::_internal_xla_gpu_deterministic_ops() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_deterministic_ops_;
}
inline void DebugOptions::_internal_set_xla_gpu_deterministic_ops(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_deterministic_ops_ = value;
}

// repeated .xla.DebugOptions.CollectiveOpType xla_gpu_disable_async_collectives = 289;
inline int DebugOptions::_internal_xla_gpu_disable_async_collectives_size() const {
  return _internal_xla_gpu_disable_async_collectives().size();
}
inline int DebugOptions::xla_gpu_disable_async_collectives_size() const {
  return _internal_xla_gpu_disable_async_collectives_size();
}
inline void DebugOptions::clear_xla_gpu_disable_async_collectives() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_disable_async_collectives_.Clear();
}
inline ::xla::DebugOptions_CollectiveOpType DebugOptions::xla_gpu_disable_async_collectives(int index) const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_disable_async_collectives)
  return static_cast<::xla::DebugOptions_CollectiveOpType>(_internal_xla_gpu_disable_async_collectives().Get(index));
}
inline void DebugOptions::set_xla_gpu_disable_async_collectives(int index, ::xla::DebugOptions_CollectiveOpType value) {
  _internal_mutable_xla_gpu_disable_async_collectives()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_disable_async_collectives)
}
inline void DebugOptions::add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_xla_gpu_disable_async_collectives()->Add(value);
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_disable_async_collectives)
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::xla_gpu_disable_async_collectives() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_disable_async_collectives)
  return _internal_xla_gpu_disable_async_collectives();
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::mutable_xla_gpu_disable_async_collectives()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_disable_async_collectives)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_gpu_disable_async_collectives();
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::_internal_xla_gpu_disable_async_collectives()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_disable_async_collectives_;
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::_internal_mutable_xla_gpu_disable_async_collectives() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_gpu_disable_async_collectives_;
}

// optional bool xla_gpu_disable_gpuasm_optimizations = 103;
inline bool DebugOptions::has_xla_gpu_disable_gpuasm_optimizations() const {
  bool value = (_impl_._has_bits_[2] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_disable_gpuasm_optimizations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_disable_gpuasm_optimizations_ = false;
  _impl_._has_bits_[2] &= ~0x04000000u;
}
inline bool DebugOptions::xla_gpu_disable_gpuasm_optimizations() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_disable_gpuasm_optimizations)
  return _internal_xla_gpu_disable_gpuasm_optimizations();
}
inline void DebugOptions::set_xla_gpu_disable_gpuasm_optimizations(bool value) {
  _internal_set_xla_gpu_disable_gpuasm_optimizations(value);
  _impl_._has_bits_[2] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_disable_gpuasm_optimizations)
}
inline bool DebugOptions::_internal_xla_gpu_disable_gpuasm_optimizations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_disable_gpuasm_optimizations_;
}
inline void DebugOptions::_internal_set_xla_gpu_disable_gpuasm_optimizations(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_disable_gpuasm_optimizations_ = value;
}

// optional int32 xla_gpu_dot_merger_threshold_mb = 331;
inline bool DebugOptions::has_xla_gpu_dot_merger_threshold_mb() const {
  bool value = (_impl_._has_bits_[5] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dot_merger_threshold_mb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dot_merger_threshold_mb_ = 0;
  _impl_._has_bits_[5] &= ~0x00080000u;
}
inline ::int32_t DebugOptions::xla_gpu_dot_merger_threshold_mb() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dot_merger_threshold_mb)
  return _internal_xla_gpu_dot_merger_threshold_mb();
}
inline void DebugOptions::set_xla_gpu_dot_merger_threshold_mb(::int32_t value) {
  _internal_set_xla_gpu_dot_merger_threshold_mb(value);
  _impl_._has_bits_[5] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dot_merger_threshold_mb)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_dot_merger_threshold_mb() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dot_merger_threshold_mb_;
}
inline void DebugOptions::_internal_set_xla_gpu_dot_merger_threshold_mb(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dot_merger_threshold_mb_ = value;
}

// optional string xla_gpu_dump_autotune_logs_to = 292;
inline bool DebugOptions::has_xla_gpu_dump_autotune_logs_to() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dump_autotune_logs_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_autotune_logs_to_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& DebugOptions::xla_gpu_dump_autotune_logs_to() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotune_logs_to)
  return _internal_xla_gpu_dump_autotune_logs_to();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_dump_autotune_logs_to(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.xla_gpu_dump_autotune_logs_to_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotune_logs_to)
}
inline std::string* DebugOptions::mutable_xla_gpu_dump_autotune_logs_to() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_dump_autotune_logs_to();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_dump_autotune_logs_to)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_dump_autotune_logs_to() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dump_autotune_logs_to_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_dump_autotune_logs_to(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.xla_gpu_dump_autotune_logs_to_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_dump_autotune_logs_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.xla_gpu_dump_autotune_logs_to_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_dump_autotune_logs_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_dump_autotune_logs_to)
  if ((_impl_._has_bits_[0] & 0x00000800u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* released = _impl_.xla_gpu_dump_autotune_logs_to_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_dump_autotune_logs_to_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_dump_autotune_logs_to(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.xla_gpu_dump_autotune_logs_to_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_dump_autotune_logs_to_.IsDefault()) {
          _impl_.xla_gpu_dump_autotune_logs_to_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_dump_autotune_logs_to)
}

// optional string xla_gpu_dump_autotune_results_to = 222;
inline bool DebugOptions::has_xla_gpu_dump_autotune_results_to() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dump_autotune_results_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_autotune_results_to_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& DebugOptions::xla_gpu_dump_autotune_results_to() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotune_results_to)
  return _internal_xla_gpu_dump_autotune_results_to();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_dump_autotune_results_to(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.xla_gpu_dump_autotune_results_to_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotune_results_to)
}
inline std::string* DebugOptions::mutable_xla_gpu_dump_autotune_results_to() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_dump_autotune_results_to();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_dump_autotune_results_to)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_dump_autotune_results_to() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dump_autotune_results_to_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_dump_autotune_results_to(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.xla_gpu_dump_autotune_results_to_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_dump_autotune_results_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.xla_gpu_dump_autotune_results_to_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_dump_autotune_results_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_dump_autotune_results_to)
  if ((_impl_._has_bits_[0] & 0x00000080u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* released = _impl_.xla_gpu_dump_autotune_results_to_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_dump_autotune_results_to_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_dump_autotune_results_to(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.xla_gpu_dump_autotune_results_to_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_dump_autotune_results_to_.IsDefault()) {
          _impl_.xla_gpu_dump_autotune_results_to_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_dump_autotune_results_to)
}

// optional bool xla_gpu_dump_autotuned_gemm_fusions = 232;
inline bool DebugOptions::has_xla_gpu_dump_autotuned_gemm_fusions() const {
  bool value = (_impl_._has_bits_[2] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dump_autotuned_gemm_fusions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_autotuned_gemm_fusions_ = false;
  _impl_._has_bits_[2] &= ~0x08000000u;
}
inline bool DebugOptions::xla_gpu_dump_autotuned_gemm_fusions() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotuned_gemm_fusions)
  return _internal_xla_gpu_dump_autotuned_gemm_fusions();
}
inline void DebugOptions::set_xla_gpu_dump_autotuned_gemm_fusions(bool value) {
  _internal_set_xla_gpu_dump_autotuned_gemm_fusions(value);
  _impl_._has_bits_[2] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotuned_gemm_fusions)
}
inline bool DebugOptions::_internal_xla_gpu_dump_autotuned_gemm_fusions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dump_autotuned_gemm_fusions_;
}
inline void DebugOptions::_internal_set_xla_gpu_dump_autotuned_gemm_fusions(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_autotuned_gemm_fusions_ = value;
}

// optional bool xla_gpu_dump_hlo_unoptimized_snapshots = 352;
inline bool DebugOptions::has_xla_gpu_dump_hlo_unoptimized_snapshots() const {
  bool value = (_impl_._has_bits_[2] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dump_hlo_unoptimized_snapshots() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_ = false;
  _impl_._has_bits_[2] &= ~0x10000000u;
}
inline bool DebugOptions::xla_gpu_dump_hlo_unoptimized_snapshots() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_hlo_unoptimized_snapshots)
  return _internal_xla_gpu_dump_hlo_unoptimized_snapshots();
}
inline void DebugOptions::set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value) {
  _internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(value);
  _impl_._has_bits_[2] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_hlo_unoptimized_snapshots)
}
inline bool DebugOptions::_internal_xla_gpu_dump_hlo_unoptimized_snapshots() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_;
}
inline void DebugOptions::_internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_ = value;
}

// optional bool xla_gpu_dump_llvmir = 155;
inline bool DebugOptions::has_xla_gpu_dump_llvmir() const {
  bool value = (_impl_._has_bits_[2] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_dump_llvmir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_llvmir_ = false;
  _impl_._has_bits_[2] &= ~0x20000000u;
}
inline bool DebugOptions::xla_gpu_dump_llvmir() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_llvmir)
  return _internal_xla_gpu_dump_llvmir();
}
inline void DebugOptions::set_xla_gpu_dump_llvmir(bool value) {
  _internal_set_xla_gpu_dump_llvmir(value);
  _impl_._has_bits_[2] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_llvmir)
}
inline bool DebugOptions::_internal_xla_gpu_dump_llvmir() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_dump_llvmir_;
}
inline void DebugOptions::_internal_set_xla_gpu_dump_llvmir(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_dump_llvmir_ = value;
}

// optional bool xla_gpu_enable_all_gather_combine_by_dim = 254;
inline bool DebugOptions::has_xla_gpu_enable_all_gather_combine_by_dim() const {
  bool value = (_impl_._has_bits_[4] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_all_gather_combine_by_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_all_gather_combine_by_dim_ = false;
  _impl_._has_bits_[4] &= ~0x20000000u;
}
inline bool DebugOptions::xla_gpu_enable_all_gather_combine_by_dim() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_all_gather_combine_by_dim)
  return _internal_xla_gpu_enable_all_gather_combine_by_dim();
}
inline void DebugOptions::set_xla_gpu_enable_all_gather_combine_by_dim(bool value) {
  _internal_set_xla_gpu_enable_all_gather_combine_by_dim(value);
  _impl_._has_bits_[4] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_all_gather_combine_by_dim)
}
inline bool DebugOptions::_internal_xla_gpu_enable_all_gather_combine_by_dim() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_all_gather_combine_by_dim_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_all_gather_combine_by_dim(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_all_gather_combine_by_dim_ = value;
}

// optional bool xla_gpu_enable_analytical_latency_estimator = 255;
inline bool DebugOptions::has_xla_gpu_enable_analytical_latency_estimator() const {
  bool value = (_impl_._has_bits_[4] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_analytical_latency_estimator() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_analytical_latency_estimator_ = false;
  _impl_._has_bits_[4] &= ~0x40000000u;
}
inline bool DebugOptions::xla_gpu_enable_analytical_latency_estimator() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_analytical_latency_estimator)
  return _internal_xla_gpu_enable_analytical_latency_estimator();
}
inline void DebugOptions::set_xla_gpu_enable_analytical_latency_estimator(bool value) {
  _internal_set_xla_gpu_enable_analytical_latency_estimator(value);
  _impl_._has_bits_[4] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_analytical_latency_estimator)
}
inline bool DebugOptions::_internal_xla_gpu_enable_analytical_latency_estimator() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_analytical_latency_estimator_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_analytical_latency_estimator(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_analytical_latency_estimator_ = value;
}

// optional bool xla_gpu_enable_analytical_sol_latency_estimator = 356;
inline bool DebugOptions::has_xla_gpu_enable_analytical_sol_latency_estimator() const {
  bool value = (_impl_._has_bits_[4] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_analytical_sol_latency_estimator() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_analytical_sol_latency_estimator_ = false;
  _impl_._has_bits_[4] &= ~0x80000000u;
}
inline bool DebugOptions::xla_gpu_enable_analytical_sol_latency_estimator() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_analytical_sol_latency_estimator)
  return _internal_xla_gpu_enable_analytical_sol_latency_estimator();
}
inline void DebugOptions::set_xla_gpu_enable_analytical_sol_latency_estimator(bool value) {
  _internal_set_xla_gpu_enable_analytical_sol_latency_estimator(value);
  _impl_._has_bits_[4] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_analytical_sol_latency_estimator)
}
inline bool DebugOptions::_internal_xla_gpu_enable_analytical_sol_latency_estimator() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_analytical_sol_latency_estimator_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_analytical_sol_latency_estimator(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_analytical_sol_latency_estimator_ = value;
}

// optional bool xla_gpu_enable_approx_costly_collectives = 305;
inline bool DebugOptions::has_xla_gpu_enable_approx_costly_collectives() const {
  bool value = (_impl_._has_bits_[5] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_approx_costly_collectives() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_approx_costly_collectives_ = false;
  _impl_._has_bits_[5] &= ~0x00000001u;
}
inline bool DebugOptions::xla_gpu_enable_approx_costly_collectives() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_approx_costly_collectives)
  return _internal_xla_gpu_enable_approx_costly_collectives();
}
inline void DebugOptions::set_xla_gpu_enable_approx_costly_collectives(bool value) {
  _internal_set_xla_gpu_enable_approx_costly_collectives(value);
  _impl_._has_bits_[5] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_approx_costly_collectives)
}
inline bool DebugOptions::_internal_xla_gpu_enable_approx_costly_collectives() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_approx_costly_collectives_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_approx_costly_collectives(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_approx_costly_collectives_ = value;
}

// repeated .xla.DebugOptions.CommandBufferCmdType xla_gpu_enable_command_buffer = 258;
inline int DebugOptions::_internal_xla_gpu_enable_command_buffer_size() const {
  return _internal_xla_gpu_enable_command_buffer().size();
}
inline int DebugOptions::xla_gpu_enable_command_buffer_size() const {
  return _internal_xla_gpu_enable_command_buffer_size();
}
inline void DebugOptions::clear_xla_gpu_enable_command_buffer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_command_buffer_.Clear();
}
inline ::xla::DebugOptions_CommandBufferCmdType DebugOptions::xla_gpu_enable_command_buffer(int index) const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_command_buffer)
  return static_cast<::xla::DebugOptions_CommandBufferCmdType>(_internal_xla_gpu_enable_command_buffer().Get(index));
}
inline void DebugOptions::set_xla_gpu_enable_command_buffer(int index, ::xla::DebugOptions_CommandBufferCmdType value) {
  _internal_mutable_xla_gpu_enable_command_buffer()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_command_buffer)
}
inline void DebugOptions::add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_xla_gpu_enable_command_buffer()->Add(value);
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_enable_command_buffer)
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::xla_gpu_enable_command_buffer() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_enable_command_buffer)
  return _internal_xla_gpu_enable_command_buffer();
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::mutable_xla_gpu_enable_command_buffer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_enable_command_buffer)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_gpu_enable_command_buffer();
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::_internal_xla_gpu_enable_command_buffer()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_command_buffer_;
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::_internal_mutable_xla_gpu_enable_command_buffer() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_gpu_enable_command_buffer_;
}

// optional bool xla_gpu_enable_cub_radix_sort = 259;
inline bool DebugOptions::has_xla_gpu_enable_cub_radix_sort() const {
  bool value = (_impl_._has_bits_[3] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_cub_radix_sort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cub_radix_sort_ = false;
  _impl_._has_bits_[3] &= ~0x00000008u;
}
inline bool DebugOptions::xla_gpu_enable_cub_radix_sort() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cub_radix_sort)
  return _internal_xla_gpu_enable_cub_radix_sort();
}
inline void DebugOptions::set_xla_gpu_enable_cub_radix_sort(bool value) {
  _internal_set_xla_gpu_enable_cub_radix_sort(value);
  _impl_._has_bits_[3] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cub_radix_sort)
}
inline bool DebugOptions::_internal_xla_gpu_enable_cub_radix_sort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_cub_radix_sort_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_cub_radix_sort(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cub_radix_sort_ = value;
}

// optional bool xla_gpu_enable_cublaslt = 166;
inline bool DebugOptions::has_xla_gpu_enable_cublaslt() const {
  bool value = (_impl_._has_bits_[3] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_cublaslt() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cublaslt_ = false;
  _impl_._has_bits_[3] &= ~0x00000010u;
}
inline bool DebugOptions::xla_gpu_enable_cublaslt() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cublaslt)
  return _internal_xla_gpu_enable_cublaslt();
}
inline void DebugOptions::set_xla_gpu_enable_cublaslt(bool value) {
  _internal_set_xla_gpu_enable_cublaslt(value);
  _impl_._has_bits_[3] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cublaslt)
}
inline bool DebugOptions::_internal_xla_gpu_enable_cublaslt() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_cublaslt_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_cublaslt(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cublaslt_ = value;
}

// optional bool xla_gpu_enable_cudnn_int8x32_convolution_reordering = 189;
inline bool DebugOptions::has_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const {
  bool value = (_impl_._has_bits_[3] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_cudnn_int8x32_convolution_reordering() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_ = false;
  _impl_._has_bits_[3] &= ~0x00000020u;
}
inline bool DebugOptions::xla_gpu_enable_cudnn_int8x32_convolution_reordering() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cudnn_int8x32_convolution_reordering)
  return _internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering();
}
inline void DebugOptions::set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value) {
  _internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(value);
  _impl_._has_bits_[3] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cudnn_int8x32_convolution_reordering)
}
inline bool DebugOptions::_internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_ = value;
}

// optional bool xla_gpu_enable_cudnn_layer_norm = 262;
inline bool DebugOptions::has_xla_gpu_enable_cudnn_layer_norm() const {
  bool value = (_impl_._has_bits_[3] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_cudnn_layer_norm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cudnn_layer_norm_ = false;
  _impl_._has_bits_[3] &= ~0x00000040u;
}
inline bool DebugOptions::xla_gpu_enable_cudnn_layer_norm() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cudnn_layer_norm)
  return _internal_xla_gpu_enable_cudnn_layer_norm();
}
inline void DebugOptions::set_xla_gpu_enable_cudnn_layer_norm(bool value) {
  _internal_set_xla_gpu_enable_cudnn_layer_norm(value);
  _impl_._has_bits_[3] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cudnn_layer_norm)
}
inline bool DebugOptions::_internal_xla_gpu_enable_cudnn_layer_norm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_cudnn_layer_norm_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_cudnn_layer_norm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_cudnn_layer_norm_ = value;
}

// optional bool xla_gpu_enable_custom_fusions = 263;
inline bool DebugOptions::has_xla_gpu_enable_custom_fusions() const {
  bool value = (_impl_._has_bits_[2] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_custom_fusions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_custom_fusions_ = false;
  _impl_._has_bits_[2] &= ~0x00000004u;
}
inline bool DebugOptions::xla_gpu_enable_custom_fusions() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_custom_fusions)
  return _internal_xla_gpu_enable_custom_fusions();
}
inline void DebugOptions::set_xla_gpu_enable_custom_fusions(bool value) {
  _internal_set_xla_gpu_enable_custom_fusions(value);
  _impl_._has_bits_[2] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_custom_fusions)
}
inline bool DebugOptions::_internal_xla_gpu_enable_custom_fusions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_custom_fusions_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_custom_fusions(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_custom_fusions_ = value;
}

// optional string xla_gpu_enable_custom_fusions_re = 264;
inline bool DebugOptions::has_xla_gpu_enable_custom_fusions_re() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_custom_fusions_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_custom_fusions_re_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& DebugOptions::xla_gpu_enable_custom_fusions_re() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_custom_fusions_re)
  return _internal_xla_gpu_enable_custom_fusions_re();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_enable_custom_fusions_re(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.xla_gpu_enable_custom_fusions_re_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_custom_fusions_re)
}
inline std::string* DebugOptions::mutable_xla_gpu_enable_custom_fusions_re() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_enable_custom_fusions_re();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_enable_custom_fusions_re)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_enable_custom_fusions_re() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_custom_fusions_re_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_enable_custom_fusions_re(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.xla_gpu_enable_custom_fusions_re_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_enable_custom_fusions_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.xla_gpu_enable_custom_fusions_re_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_enable_custom_fusions_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_enable_custom_fusions_re)
  if ((_impl_._has_bits_[0] & 0x00000400u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* released = _impl_.xla_gpu_enable_custom_fusions_re_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_enable_custom_fusions_re_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_enable_custom_fusions_re(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.xla_gpu_enable_custom_fusions_re_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_enable_custom_fusions_re_.IsDefault()) {
          _impl_.xla_gpu_enable_custom_fusions_re_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_enable_custom_fusions_re)
}

// optional bool xla_gpu_enable_dynamic_slice_fusion = 105;
inline bool DebugOptions::has_xla_gpu_enable_dynamic_slice_fusion() const {
  bool value = (_impl_._has_bits_[2] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_dynamic_slice_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_dynamic_slice_fusion_ = false;
  _impl_._has_bits_[2] &= ~0x00000008u;
}
inline bool DebugOptions::xla_gpu_enable_dynamic_slice_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_dynamic_slice_fusion)
  return _internal_xla_gpu_enable_dynamic_slice_fusion();
}
inline void DebugOptions::set_xla_gpu_enable_dynamic_slice_fusion(bool value) {
  _internal_set_xla_gpu_enable_dynamic_slice_fusion(value);
  _impl_._has_bits_[2] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_dynamic_slice_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_enable_dynamic_slice_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_dynamic_slice_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_dynamic_slice_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_dynamic_slice_fusion_ = value;
}

// optional bool xla_gpu_enable_fast_min_max = 100;
inline bool DebugOptions::has_xla_gpu_enable_fast_min_max() const {
  bool value = (_impl_._has_bits_[2] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_fast_min_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_fast_min_max_ = false;
  _impl_._has_bits_[2] &= ~0x00000010u;
}
inline bool DebugOptions::xla_gpu_enable_fast_min_max() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_fast_min_max)
  return _internal_xla_gpu_enable_fast_min_max();
}
inline void DebugOptions::set_xla_gpu_enable_fast_min_max(bool value) {
  _internal_set_xla_gpu_enable_fast_min_max(value);
  _impl_._has_bits_[2] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_fast_min_max)
}
inline bool DebugOptions::_internal_xla_gpu_enable_fast_min_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_fast_min_max_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_fast_min_max(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_fast_min_max_ = value;
}

// optional bool xla_gpu_enable_highest_priority_async_stream = 216;
inline bool DebugOptions::has_xla_gpu_enable_highest_priority_async_stream() const {
  bool value = (_impl_._has_bits_[2] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_highest_priority_async_stream() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_highest_priority_async_stream_ = false;
  _impl_._has_bits_[2] &= ~0x00000020u;
}
inline bool DebugOptions::xla_gpu_enable_highest_priority_async_stream() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_highest_priority_async_stream)
  return _internal_xla_gpu_enable_highest_priority_async_stream();
}
inline void DebugOptions::set_xla_gpu_enable_highest_priority_async_stream(bool value) {
  _internal_set_xla_gpu_enable_highest_priority_async_stream(value);
  _impl_._has_bits_[2] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_highest_priority_async_stream)
}
inline bool DebugOptions::_internal_xla_gpu_enable_highest_priority_async_stream() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_highest_priority_async_stream_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_highest_priority_async_stream(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_highest_priority_async_stream_ = value;
}

// optional bool xla_gpu_enable_host_memory_offloading = 296;
inline bool DebugOptions::has_xla_gpu_enable_host_memory_offloading() const {
  bool value = (_impl_._has_bits_[4] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_host_memory_offloading() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_host_memory_offloading_ = false;
  _impl_._has_bits_[4] &= ~0x00000010u;
}
inline bool DebugOptions::xla_gpu_enable_host_memory_offloading() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_host_memory_offloading)
  return _internal_xla_gpu_enable_host_memory_offloading();
}
inline void DebugOptions::set_xla_gpu_enable_host_memory_offloading(bool value) {
  _internal_set_xla_gpu_enable_host_memory_offloading(value);
  _impl_._has_bits_[4] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_host_memory_offloading)
}
inline bool DebugOptions::_internal_xla_gpu_enable_host_memory_offloading() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_host_memory_offloading_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_host_memory_offloading(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_host_memory_offloading_ = value;
}

// optional bool xla_gpu_enable_latency_hiding_scheduler = 186;
inline bool DebugOptions::has_xla_gpu_enable_latency_hiding_scheduler() const {
  bool value = (_impl_._has_bits_[4] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_latency_hiding_scheduler() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_latency_hiding_scheduler_ = false;
  _impl_._has_bits_[4] &= ~0x00000020u;
}
inline bool DebugOptions::xla_gpu_enable_latency_hiding_scheduler() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_latency_hiding_scheduler)
  return _internal_xla_gpu_enable_latency_hiding_scheduler();
}
inline void DebugOptions::set_xla_gpu_enable_latency_hiding_scheduler(bool value) {
  _internal_set_xla_gpu_enable_latency_hiding_scheduler(value);
  _impl_._has_bits_[4] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_latency_hiding_scheduler)
}
inline bool DebugOptions::_internal_xla_gpu_enable_latency_hiding_scheduler() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_latency_hiding_scheduler_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_latency_hiding_scheduler(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_latency_hiding_scheduler_ = value;
}

// optional bool xla_gpu_enable_libnvptxcompiler = 269;
inline bool DebugOptions::has_xla_gpu_enable_libnvptxcompiler() const {
  bool value = (_impl_._has_bits_[4] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_libnvptxcompiler() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_libnvptxcompiler_ = false;
  _impl_._has_bits_[4] &= ~0x00000040u;
}
inline bool DebugOptions::xla_gpu_enable_libnvptxcompiler() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_libnvptxcompiler)
  return _internal_xla_gpu_enable_libnvptxcompiler();
}
inline void DebugOptions::set_xla_gpu_enable_libnvptxcompiler(bool value) {
  _internal_set_xla_gpu_enable_libnvptxcompiler(value);
  _impl_._has_bits_[4] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_libnvptxcompiler)
}
inline bool DebugOptions::_internal_xla_gpu_enable_libnvptxcompiler() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_libnvptxcompiler_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_libnvptxcompiler(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_libnvptxcompiler_ = value;
}

// optional bool xla_gpu_enable_llvm_module_compilation_parallelism = 268;
inline bool DebugOptions::has_xla_gpu_enable_llvm_module_compilation_parallelism() const {
  bool value = (_impl_._has_bits_[4] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_llvm_module_compilation_parallelism() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_ = false;
  _impl_._has_bits_[4] &= ~0x00000080u;
}
inline bool DebugOptions::xla_gpu_enable_llvm_module_compilation_parallelism() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_llvm_module_compilation_parallelism)
  return _internal_xla_gpu_enable_llvm_module_compilation_parallelism();
}
inline void DebugOptions::set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value) {
  _internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(value);
  _impl_._has_bits_[4] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_llvm_module_compilation_parallelism)
}
inline bool DebugOptions::_internal_xla_gpu_enable_llvm_module_compilation_parallelism() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_ = value;
}

// optional bool xla_gpu_enable_nccl_clique_optimization = 244 [deprecated = true];
inline bool DebugOptions::has_xla_gpu_enable_nccl_clique_optimization() const {
  bool value = (_impl_._has_bits_[4] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_nccl_clique_optimization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_clique_optimization_ = false;
  _impl_._has_bits_[4] &= ~0x00000001u;
}
inline bool DebugOptions::xla_gpu_enable_nccl_clique_optimization() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_clique_optimization)
  return _internal_xla_gpu_enable_nccl_clique_optimization();
}
inline void DebugOptions::set_xla_gpu_enable_nccl_clique_optimization(bool value) {
  _internal_set_xla_gpu_enable_nccl_clique_optimization(value);
  _impl_._has_bits_[4] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_clique_optimization)
}
inline bool DebugOptions::_internal_xla_gpu_enable_nccl_clique_optimization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_nccl_clique_optimization_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_clique_optimization(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_clique_optimization_ = value;
}

// optional bool xla_gpu_enable_nccl_comm_splitting = 272;
inline bool DebugOptions::has_xla_gpu_enable_nccl_comm_splitting() const {
  bool value = (_impl_._has_bits_[4] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_nccl_comm_splitting() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_comm_splitting_ = false;
  _impl_._has_bits_[4] &= ~0x00000002u;
}
inline bool DebugOptions::xla_gpu_enable_nccl_comm_splitting() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_comm_splitting)
  return _internal_xla_gpu_enable_nccl_comm_splitting();
}
inline void DebugOptions::set_xla_gpu_enable_nccl_comm_splitting(bool value) {
  _internal_set_xla_gpu_enable_nccl_comm_splitting(value);
  _impl_._has_bits_[4] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_comm_splitting)
}
inline bool DebugOptions::_internal_xla_gpu_enable_nccl_comm_splitting() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_nccl_comm_splitting_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_comm_splitting(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_comm_splitting_ = value;
}

// optional bool xla_gpu_enable_nccl_user_buffers = 267;
inline bool DebugOptions::has_xla_gpu_enable_nccl_user_buffers() const {
  bool value = (_impl_._has_bits_[4] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_nccl_user_buffers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_user_buffers_ = false;
  _impl_._has_bits_[4] &= ~0x00000004u;
}
inline bool DebugOptions::xla_gpu_enable_nccl_user_buffers() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_user_buffers)
  return _internal_xla_gpu_enable_nccl_user_buffers();
}
inline void DebugOptions::set_xla_gpu_enable_nccl_user_buffers(bool value) {
  _internal_set_xla_gpu_enable_nccl_user_buffers(value);
  _impl_._has_bits_[4] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_user_buffers)
}
inline bool DebugOptions::_internal_xla_gpu_enable_nccl_user_buffers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_nccl_user_buffers_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_user_buffers(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_nccl_user_buffers_ = value;
}

// optional bool xla_gpu_enable_pipelined_all_gather = 227;
inline bool DebugOptions::has_xla_gpu_enable_pipelined_all_gather() const {
  bool value = (_impl_._has_bits_[4] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_pipelined_all_gather() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_all_gather_ = false;
  _impl_._has_bits_[4] &= ~0x00000008u;
}
inline bool DebugOptions::xla_gpu_enable_pipelined_all_gather() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_all_gather)
  return _internal_xla_gpu_enable_pipelined_all_gather();
}
inline void DebugOptions::set_xla_gpu_enable_pipelined_all_gather(bool value) {
  _internal_set_xla_gpu_enable_pipelined_all_gather(value);
  _impl_._has_bits_[4] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_all_gather)
}
inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_all_gather() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_pipelined_all_gather_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_all_gather(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_all_gather_ = value;
}

// optional bool xla_gpu_enable_pipelined_all_reduce = 217;
inline bool DebugOptions::has_xla_gpu_enable_pipelined_all_reduce() const {
  bool value = (_impl_._has_bits_[3] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_pipelined_all_reduce() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_all_reduce_ = false;
  _impl_._has_bits_[3] &= ~0x00004000u;
}
inline bool DebugOptions::xla_gpu_enable_pipelined_all_reduce() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_all_reduce)
  return _internal_xla_gpu_enable_pipelined_all_reduce();
}
inline void DebugOptions::set_xla_gpu_enable_pipelined_all_reduce(bool value) {
  _internal_set_xla_gpu_enable_pipelined_all_reduce(value);
  _impl_._has_bits_[3] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_all_reduce)
}
inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_all_reduce() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_pipelined_all_reduce_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_all_reduce(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_all_reduce_ = value;
}

// optional bool xla_gpu_enable_pipelined_collectives = 239 [deprecated = true];
inline bool DebugOptions::has_xla_gpu_enable_pipelined_collectives() const {
  bool value = (_impl_._has_bits_[3] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_pipelined_collectives() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_collectives_ = false;
  _impl_._has_bits_[3] &= ~0x00008000u;
}
inline bool DebugOptions::xla_gpu_enable_pipelined_collectives() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_collectives)
  return _internal_xla_gpu_enable_pipelined_collectives();
}
inline void DebugOptions::set_xla_gpu_enable_pipelined_collectives(bool value) {
  _internal_set_xla_gpu_enable_pipelined_collectives(value);
  _impl_._has_bits_[3] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_collectives)
}
inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_collectives() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_pipelined_collectives_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_collectives(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_collectives_ = value;
}

// optional bool xla_gpu_enable_pipelined_p2p = 246;
inline bool DebugOptions::has_xla_gpu_enable_pipelined_p2p() const {
  bool value = (_impl_._has_bits_[3] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_pipelined_p2p() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_p2p_ = false;
  _impl_._has_bits_[3] &= ~0x00010000u;
}
inline bool DebugOptions::xla_gpu_enable_pipelined_p2p() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_p2p)
  return _internal_xla_gpu_enable_pipelined_p2p();
}
inline void DebugOptions::set_xla_gpu_enable_pipelined_p2p(bool value) {
  _internal_set_xla_gpu_enable_pipelined_p2p(value);
  _impl_._has_bits_[3] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_p2p)
}
inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_p2p() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_pipelined_p2p_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_p2p(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_p2p_ = value;
}

// optional bool xla_gpu_enable_pipelined_reduce_scatter = 231;
inline bool DebugOptions::has_xla_gpu_enable_pipelined_reduce_scatter() const {
  bool value = (_impl_._has_bits_[3] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_pipelined_reduce_scatter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_reduce_scatter_ = false;
  _impl_._has_bits_[3] &= ~0x00020000u;
}
inline bool DebugOptions::xla_gpu_enable_pipelined_reduce_scatter() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_reduce_scatter)
  return _internal_xla_gpu_enable_pipelined_reduce_scatter();
}
inline void DebugOptions::set_xla_gpu_enable_pipelined_reduce_scatter(bool value) {
  _internal_set_xla_gpu_enable_pipelined_reduce_scatter(value);
  _impl_._has_bits_[3] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_reduce_scatter)
}
inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_reduce_scatter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_pipelined_reduce_scatter_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_reduce_scatter(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_pipelined_reduce_scatter_ = value;
}

// optional bool xla_gpu_enable_reassociation_for_converted_ar = 209;
inline bool DebugOptions::has_xla_gpu_enable_reassociation_for_converted_ar() const {
  bool value = (_impl_._has_bits_[4] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_reassociation_for_converted_ar() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reassociation_for_converted_ar_ = false;
  _impl_._has_bits_[4] &= ~0x00000800u;
}
inline bool DebugOptions::xla_gpu_enable_reassociation_for_converted_ar() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reassociation_for_converted_ar)
  return _internal_xla_gpu_enable_reassociation_for_converted_ar();
}
inline void DebugOptions::set_xla_gpu_enable_reassociation_for_converted_ar(bool value) {
  _internal_set_xla_gpu_enable_reassociation_for_converted_ar(value);
  _impl_._has_bits_[4] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reassociation_for_converted_ar)
}
inline bool DebugOptions::_internal_xla_gpu_enable_reassociation_for_converted_ar() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_reassociation_for_converted_ar_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_reassociation_for_converted_ar(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reassociation_for_converted_ar_ = value;
}

// optional bool xla_gpu_enable_reduce_scatter_combine_by_dim = 257;
inline bool DebugOptions::has_xla_gpu_enable_reduce_scatter_combine_by_dim() const {
  bool value = (_impl_._has_bits_[4] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_reduce_scatter_combine_by_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_ = false;
  _impl_._has_bits_[4] &= ~0x00001000u;
}
inline bool DebugOptions::xla_gpu_enable_reduce_scatter_combine_by_dim() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reduce_scatter_combine_by_dim)
  return _internal_xla_gpu_enable_reduce_scatter_combine_by_dim();
}
inline void DebugOptions::set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value) {
  _internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(value);
  _impl_._has_bits_[4] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reduce_scatter_combine_by_dim)
}
inline bool DebugOptions::_internal_xla_gpu_enable_reduce_scatter_combine_by_dim() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_ = value;
}

// optional bool xla_gpu_enable_reduction_epilogue_fusion = 243;
inline bool DebugOptions::has_xla_gpu_enable_reduction_epilogue_fusion() const {
  bool value = (_impl_._has_bits_[4] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_reduction_epilogue_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reduction_epilogue_fusion_ = false;
  _impl_._has_bits_[4] &= ~0x00002000u;
}
inline bool DebugOptions::xla_gpu_enable_reduction_epilogue_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reduction_epilogue_fusion)
  return _internal_xla_gpu_enable_reduction_epilogue_fusion();
}
inline void DebugOptions::set_xla_gpu_enable_reduction_epilogue_fusion(bool value) {
  _internal_set_xla_gpu_enable_reduction_epilogue_fusion(value);
  _impl_._has_bits_[4] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reduction_epilogue_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_enable_reduction_epilogue_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_reduction_epilogue_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_reduction_epilogue_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_reduction_epilogue_fusion_ = value;
}

// optional bool xla_gpu_enable_scatter_determinism_expander = 345;
inline bool DebugOptions::has_xla_gpu_enable_scatter_determinism_expander() const {
  bool value = (_impl_._has_bits_[4] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_scatter_determinism_expander() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_scatter_determinism_expander_ = false;
  _impl_._has_bits_[4] &= ~0x00004000u;
}
inline bool DebugOptions::xla_gpu_enable_scatter_determinism_expander() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_scatter_determinism_expander)
  return _internal_xla_gpu_enable_scatter_determinism_expander();
}
inline void DebugOptions::set_xla_gpu_enable_scatter_determinism_expander(bool value) {
  _internal_set_xla_gpu_enable_scatter_determinism_expander(value);
  _impl_._has_bits_[4] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_scatter_determinism_expander)
}
inline bool DebugOptions::_internal_xla_gpu_enable_scatter_determinism_expander() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_scatter_determinism_expander_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_scatter_determinism_expander(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_scatter_determinism_expander_ = value;
}

// optional bool xla_gpu_enable_shared_constants = 165;
inline bool DebugOptions::has_xla_gpu_enable_shared_constants() const {
  bool value = (_impl_._has_bits_[2] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_shared_constants() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_shared_constants_ = false;
  _impl_._has_bits_[2] &= ~0x40000000u;
}
inline bool DebugOptions::xla_gpu_enable_shared_constants() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_shared_constants)
  return _internal_xla_gpu_enable_shared_constants();
}
inline void DebugOptions::set_xla_gpu_enable_shared_constants(bool value) {
  _internal_set_xla_gpu_enable_shared_constants(value);
  _impl_._has_bits_[2] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_shared_constants)
}
inline bool DebugOptions::_internal_xla_gpu_enable_shared_constants() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_shared_constants_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_shared_constants(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_shared_constants_ = value;
}

// optional bool xla_gpu_enable_split_k_autotuning = 241;
inline bool DebugOptions::has_xla_gpu_enable_split_k_autotuning() const {
  bool value = (_impl_._has_bits_[2] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_split_k_autotuning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_split_k_autotuning_ = false;
  _impl_._has_bits_[2] &= ~0x80000000u;
}
inline bool DebugOptions::xla_gpu_enable_split_k_autotuning() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_split_k_autotuning)
  return _internal_xla_gpu_enable_split_k_autotuning();
}
inline void DebugOptions::set_xla_gpu_enable_split_k_autotuning(bool value) {
  _internal_set_xla_gpu_enable_split_k_autotuning(value);
  _impl_._has_bits_[2] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_split_k_autotuning)
}
inline bool DebugOptions::_internal_xla_gpu_enable_split_k_autotuning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_split_k_autotuning_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_split_k_autotuning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_split_k_autotuning_ = value;
}

// optional bool xla_gpu_enable_triton_gemm = 188;
inline bool DebugOptions::has_xla_gpu_enable_triton_gemm() const {
  bool value = (_impl_._has_bits_[3] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_triton_gemm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_triton_gemm_ = false;
  _impl_._has_bits_[3] &= ~0x00000001u;
}
inline bool DebugOptions::xla_gpu_enable_triton_gemm() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_triton_gemm)
  return _internal_xla_gpu_enable_triton_gemm();
}
inline void DebugOptions::set_xla_gpu_enable_triton_gemm(bool value) {
  _internal_set_xla_gpu_enable_triton_gemm(value);
  _impl_._has_bits_[3] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_triton_gemm)
}
inline bool DebugOptions::_internal_xla_gpu_enable_triton_gemm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_triton_gemm_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_triton_gemm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_triton_gemm_ = value;
}

// optional bool xla_gpu_enable_triton_hopper = 266;
inline bool DebugOptions::has_xla_gpu_enable_triton_hopper() const {
  bool value = (_impl_._has_bits_[3] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_triton_hopper() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_triton_hopper_ = false;
  _impl_._has_bits_[3] &= ~0x00000002u;
}
inline bool DebugOptions::xla_gpu_enable_triton_hopper() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_triton_hopper)
  return _internal_xla_gpu_enable_triton_hopper();
}
inline void DebugOptions::set_xla_gpu_enable_triton_hopper(bool value) {
  _internal_set_xla_gpu_enable_triton_hopper(value);
  _impl_._has_bits_[3] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_triton_hopper)
}
inline bool DebugOptions::_internal_xla_gpu_enable_triton_hopper() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_triton_hopper_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_triton_hopper(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_triton_hopper_ = value;
}

// optional bool xla_gpu_enable_while_loop_double_buffering = 248;
inline bool DebugOptions::has_xla_gpu_enable_while_loop_double_buffering() const {
  bool value = (_impl_._has_bits_[3] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_while_loop_double_buffering() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_double_buffering_ = false;
  _impl_._has_bits_[3] &= ~0x00800000u;
}
inline bool DebugOptions::xla_gpu_enable_while_loop_double_buffering() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_double_buffering)
  return _internal_xla_gpu_enable_while_loop_double_buffering();
}
inline void DebugOptions::set_xla_gpu_enable_while_loop_double_buffering(bool value) {
  _internal_set_xla_gpu_enable_while_loop_double_buffering(value);
  _impl_._has_bits_[3] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_double_buffering)
}
inline bool DebugOptions::_internal_xla_gpu_enable_while_loop_double_buffering() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_while_loop_double_buffering_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_double_buffering(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_double_buffering_ = value;
}

// optional bool xla_gpu_enable_while_loop_reduce_scatter_code_motion = 203;
inline bool DebugOptions::has_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const {
  bool value = (_impl_._has_bits_[3] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_while_loop_reduce_scatter_code_motion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_ = false;
  _impl_._has_bits_[3] &= ~0x01000000u;
}
inline bool DebugOptions::xla_gpu_enable_while_loop_reduce_scatter_code_motion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_reduce_scatter_code_motion)
  return _internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion();
}
inline void DebugOptions::set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value) {
  _internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(value);
  _impl_._has_bits_[3] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_reduce_scatter_code_motion)
}
inline bool DebugOptions::_internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_;
}
inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_ = value;
}

// optional .xla.DebugOptions.WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling = 294;
inline bool DebugOptions::has_xla_gpu_enable_while_loop_unrolling() const {
  bool value = (_impl_._has_bits_[5] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_enable_while_loop_unrolling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_unrolling_ = 0;
  _impl_._has_bits_[5] &= ~0x00000002u;
}
inline ::xla::DebugOptions_WhileLoopUnrolling DebugOptions::xla_gpu_enable_while_loop_unrolling() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_unrolling)
  return _internal_xla_gpu_enable_while_loop_unrolling();
}
inline void DebugOptions::set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value) {
  _internal_set_xla_gpu_enable_while_loop_unrolling(value);
  _impl_._has_bits_[5] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_unrolling)
}
inline ::xla::DebugOptions_WhileLoopUnrolling DebugOptions::_internal_xla_gpu_enable_while_loop_unrolling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_WhileLoopUnrolling>(_impl_.xla_gpu_enable_while_loop_unrolling_);
}
inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_enable_while_loop_unrolling_ = value;
}

// optional bool xla_gpu_exclude_nondeterministic_ops = 297;
inline bool DebugOptions::has_xla_gpu_exclude_nondeterministic_ops() const {
  bool value = (_impl_._has_bits_[3] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_exclude_nondeterministic_ops() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_exclude_nondeterministic_ops_ = false;
  _impl_._has_bits_[3] &= ~0x02000000u;
}
inline bool DebugOptions::xla_gpu_exclude_nondeterministic_ops() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_exclude_nondeterministic_ops)
  return _internal_xla_gpu_exclude_nondeterministic_ops();
}
inline void DebugOptions::set_xla_gpu_exclude_nondeterministic_ops(bool value) {
  _internal_set_xla_gpu_exclude_nondeterministic_ops(value);
  _impl_._has_bits_[3] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_exclude_nondeterministic_ops)
}
inline bool DebugOptions::_internal_xla_gpu_exclude_nondeterministic_ops() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_exclude_nondeterministic_ops_;
}
inline void DebugOptions::_internal_set_xla_gpu_exclude_nondeterministic_ops(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_exclude_nondeterministic_ops_ = value;
}

// optional int32 xla_gpu_executable_terminate_timeout_seconds = 328;
inline bool DebugOptions::has_xla_gpu_executable_terminate_timeout_seconds() const {
  bool value = (_impl_._has_bits_[5] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_executable_terminate_timeout_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_executable_terminate_timeout_seconds_ = 0;
  _impl_._has_bits_[5] &= ~0x00040000u;
}
inline ::int32_t DebugOptions::xla_gpu_executable_terminate_timeout_seconds() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_executable_terminate_timeout_seconds)
  return _internal_xla_gpu_executable_terminate_timeout_seconds();
}
inline void DebugOptions::set_xla_gpu_executable_terminate_timeout_seconds(::int32_t value) {
  _internal_set_xla_gpu_executable_terminate_timeout_seconds(value);
  _impl_._has_bits_[5] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_executable_terminate_timeout_seconds)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_executable_terminate_timeout_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_executable_terminate_timeout_seconds_;
}
inline void DebugOptions::_internal_set_xla_gpu_executable_terminate_timeout_seconds(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_executable_terminate_timeout_seconds_ = value;
}

// optional int32 xla_gpu_executable_warn_stuck_timeout_seconds = 327;
inline bool DebugOptions::has_xla_gpu_executable_warn_stuck_timeout_seconds() const {
  bool value = (_impl_._has_bits_[5] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_executable_warn_stuck_timeout_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_ = 0;
  _impl_._has_bits_[5] &= ~0x00020000u;
}
inline ::int32_t DebugOptions::xla_gpu_executable_warn_stuck_timeout_seconds() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_executable_warn_stuck_timeout_seconds)
  return _internal_xla_gpu_executable_warn_stuck_timeout_seconds();
}
inline void DebugOptions::set_xla_gpu_executable_warn_stuck_timeout_seconds(::int32_t value) {
  _internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(value);
  _impl_._has_bits_[5] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_executable_warn_stuck_timeout_seconds)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_executable_warn_stuck_timeout_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_;
}
inline void DebugOptions::_internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_ = value;
}

// optional bool xla_gpu_exhaustive_tiling_search = 219;
inline bool DebugOptions::has_xla_gpu_exhaustive_tiling_search() const {
  bool value = (_impl_._has_bits_[3] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_exhaustive_tiling_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_exhaustive_tiling_search_ = false;
  _impl_._has_bits_[3] &= ~0x04000000u;
}
inline bool DebugOptions::xla_gpu_exhaustive_tiling_search() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_exhaustive_tiling_search)
  return _internal_xla_gpu_exhaustive_tiling_search();
}
inline void DebugOptions::set_xla_gpu_exhaustive_tiling_search(bool value) {
  _internal_set_xla_gpu_exhaustive_tiling_search(value);
  _impl_._has_bits_[3] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_exhaustive_tiling_search)
}
inline bool DebugOptions::_internal_xla_gpu_exhaustive_tiling_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_exhaustive_tiling_search_;
}
inline void DebugOptions::_internal_set_xla_gpu_exhaustive_tiling_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_exhaustive_tiling_search_ = value;
}

// optional .xla.DebugOptions.AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode = 324;
inline bool DebugOptions::has_xla_gpu_experimental_autotune_cache_mode() const {
  bool value = (_impl_._has_bits_[5] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_autotune_cache_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_autotune_cache_mode_ = 0;
  _impl_._has_bits_[5] &= ~0x00001000u;
}
inline ::xla::DebugOptions_AutotuneCacheMode DebugOptions::xla_gpu_experimental_autotune_cache_mode() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_autotune_cache_mode)
  return _internal_xla_gpu_experimental_autotune_cache_mode();
}
inline void DebugOptions::set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value) {
  _internal_set_xla_gpu_experimental_autotune_cache_mode(value);
  _impl_._has_bits_[5] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_autotune_cache_mode)
}
inline ::xla::DebugOptions_AutotuneCacheMode DebugOptions::_internal_xla_gpu_experimental_autotune_cache_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_AutotuneCacheMode>(_impl_.xla_gpu_experimental_autotune_cache_mode_);
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_autotune_cache_mode_ = value;
}

// optional int64 xla_gpu_experimental_collective_cse_distance_threshold = 374;
inline bool DebugOptions::has_xla_gpu_experimental_collective_cse_distance_threshold() const {
  bool value = (_impl_._has_bits_[6] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_collective_cse_distance_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_collective_cse_distance_threshold_ = ::int64_t{0};
  _impl_._has_bits_[6] &= ~0x40000000u;
}
inline ::int64_t DebugOptions::xla_gpu_experimental_collective_cse_distance_threshold() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_collective_cse_distance_threshold)
  return _internal_xla_gpu_experimental_collective_cse_distance_threshold();
}
inline void DebugOptions::set_xla_gpu_experimental_collective_cse_distance_threshold(::int64_t value) {
  _internal_set_xla_gpu_experimental_collective_cse_distance_threshold(value);
  _impl_._has_bits_[6] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_collective_cse_distance_threshold)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_experimental_collective_cse_distance_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_collective_cse_distance_threshold_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_collective_cse_distance_threshold(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_collective_cse_distance_threshold_ = value;
}

// optional string xla_gpu_experimental_collective_perf_table_path = 377;
inline bool DebugOptions::has_xla_gpu_experimental_collective_perf_table_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_collective_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_collective_perf_table_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const std::string& DebugOptions::xla_gpu_experimental_collective_perf_table_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_collective_perf_table_path)
  return _internal_xla_gpu_experimental_collective_perf_table_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_experimental_collective_perf_table_path(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.xla_gpu_experimental_collective_perf_table_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_collective_perf_table_path)
}
inline std::string* DebugOptions::mutable_xla_gpu_experimental_collective_perf_table_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_experimental_collective_perf_table_path();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_experimental_collective_perf_table_path)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_experimental_collective_perf_table_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_collective_perf_table_path_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_collective_perf_table_path(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.xla_gpu_experimental_collective_perf_table_path_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_experimental_collective_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00010000u;
  return _impl_.xla_gpu_experimental_collective_perf_table_path_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_experimental_collective_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_experimental_collective_perf_table_path)
  if ((_impl_._has_bits_[0] & 0x00010000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00010000u;
  auto* released = _impl_.xla_gpu_experimental_collective_perf_table_path_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_experimental_collective_perf_table_path_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_experimental_collective_perf_table_path(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.xla_gpu_experimental_collective_perf_table_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_experimental_collective_perf_table_path_.IsDefault()) {
          _impl_.xla_gpu_experimental_collective_perf_table_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_experimental_collective_perf_table_path)
}

// optional bool xla_gpu_experimental_disable_binary_libraries = 329;
inline bool DebugOptions::has_xla_gpu_experimental_disable_binary_libraries() const {
  bool value = (_impl_._has_bits_[6] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_disable_binary_libraries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_disable_binary_libraries_ = false;
  _impl_._has_bits_[6] &= ~0x00000020u;
}
inline bool DebugOptions::xla_gpu_experimental_disable_binary_libraries() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_disable_binary_libraries)
  return _internal_xla_gpu_experimental_disable_binary_libraries();
}
inline void DebugOptions::set_xla_gpu_experimental_disable_binary_libraries(bool value) {
  _internal_set_xla_gpu_experimental_disable_binary_libraries(value);
  _impl_._has_bits_[6] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_disable_binary_libraries)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_disable_binary_libraries() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_disable_binary_libraries_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_disable_binary_libraries(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_disable_binary_libraries_ = value;
}

// optional bool xla_gpu_experimental_dump_fdo_profiles = 338;
inline bool DebugOptions::has_xla_gpu_experimental_dump_fdo_profiles() const {
  bool value = (_impl_._has_bits_[6] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_dump_fdo_profiles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_dump_fdo_profiles_ = false;
  _impl_._has_bits_[6] &= ~0x00000040u;
}
inline bool DebugOptions::xla_gpu_experimental_dump_fdo_profiles() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_dump_fdo_profiles)
  return _internal_xla_gpu_experimental_dump_fdo_profiles();
}
inline void DebugOptions::set_xla_gpu_experimental_dump_fdo_profiles(bool value) {
  _internal_set_xla_gpu_experimental_dump_fdo_profiles(value);
  _impl_._has_bits_[6] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_dump_fdo_profiles)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_dump_fdo_profiles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_dump_fdo_profiles_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_dump_fdo_profiles(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_dump_fdo_profiles_ = value;
}

// optional bool xla_gpu_experimental_enable_alltoall_windowed_einsum = 360;
inline bool DebugOptions::has_xla_gpu_experimental_enable_alltoall_windowed_einsum() const {
  bool value = (_impl_._has_bits_[6] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_alltoall_windowed_einsum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_ = false;
  _impl_._has_bits_[6] &= ~0x00000080u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_alltoall_windowed_einsum() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_alltoall_windowed_einsum)
  return _internal_xla_gpu_experimental_enable_alltoall_windowed_einsum();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value) {
  _internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(value);
  _impl_._has_bits_[6] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_alltoall_windowed_einsum)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_alltoall_windowed_einsum() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_ = value;
}

// optional bool xla_gpu_experimental_enable_command_buffer_on_thunks = 394;
inline bool DebugOptions::has_xla_gpu_experimental_enable_command_buffer_on_thunks() const {
  bool value = (_impl_._has_bits_[6] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_command_buffer_on_thunks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_command_buffer_on_thunks_ = false;
  _impl_._has_bits_[6] &= ~0x00000100u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_command_buffer_on_thunks() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_command_buffer_on_thunks)
  return _internal_xla_gpu_experimental_enable_command_buffer_on_thunks();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_command_buffer_on_thunks(bool value) {
  _internal_set_xla_gpu_experimental_enable_command_buffer_on_thunks(value);
  _impl_._has_bits_[6] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_command_buffer_on_thunks)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_command_buffer_on_thunks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_command_buffer_on_thunks_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_command_buffer_on_thunks(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_command_buffer_on_thunks_ = value;
}

// optional bool xla_gpu_experimental_enable_fusion_block_level_rewriter = 334;
inline bool DebugOptions::has_xla_gpu_experimental_enable_fusion_block_level_rewriter() const {
  bool value = (_impl_._has_bits_[6] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_fusion_block_level_rewriter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_ = false;
  _impl_._has_bits_[6] &= ~0x00400000u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_fusion_block_level_rewriter() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_fusion_block_level_rewriter)
  return _internal_xla_gpu_experimental_enable_fusion_block_level_rewriter();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value) {
  _internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(value);
  _impl_._has_bits_[6] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_fusion_block_level_rewriter)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_fusion_block_level_rewriter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_ = value;
}

// optional bool xla_gpu_experimental_enable_heuristic_collective_combining = 366;
inline bool DebugOptions::has_xla_gpu_experimental_enable_heuristic_collective_combining() const {
  bool value = (_impl_._has_bits_[6] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_heuristic_collective_combining() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_heuristic_collective_combining_ = false;
  _impl_._has_bits_[6] &= ~0x00800000u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_heuristic_collective_combining() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_heuristic_collective_combining)
  return _internal_xla_gpu_experimental_enable_heuristic_collective_combining();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_heuristic_collective_combining(bool value) {
  _internal_set_xla_gpu_experimental_enable_heuristic_collective_combining(value);
  _impl_._has_bits_[6] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_heuristic_collective_combining)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_heuristic_collective_combining() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_heuristic_collective_combining_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_heuristic_collective_combining(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_heuristic_collective_combining_ = value;
}

// optional bool xla_gpu_experimental_enable_nvshmem = 388;
inline bool DebugOptions::has_xla_gpu_experimental_enable_nvshmem() const {
  bool value = (_impl_._has_bits_[6] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_nvshmem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_nvshmem_ = false;
  _impl_._has_bits_[6] &= ~0x01000000u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_nvshmem() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_nvshmem)
  return _internal_xla_gpu_experimental_enable_nvshmem();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_nvshmem(bool value) {
  _internal_set_xla_gpu_experimental_enable_nvshmem(value);
  _impl_._has_bits_[6] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_nvshmem)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_nvshmem() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_nvshmem_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_nvshmem(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_nvshmem_ = value;
}

// optional bool xla_gpu_experimental_enable_split_k_rewrite = 386;
inline bool DebugOptions::has_xla_gpu_experimental_enable_split_k_rewrite() const {
  bool value = (_impl_._has_bits_[6] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_split_k_rewrite() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_split_k_rewrite_ = false;
  _impl_._has_bits_[6] &= ~0x02000000u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_split_k_rewrite() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_split_k_rewrite)
  return _internal_xla_gpu_experimental_enable_split_k_rewrite();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_split_k_rewrite(bool value) {
  _internal_set_xla_gpu_experimental_enable_split_k_rewrite(value);
  _impl_._has_bits_[6] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_split_k_rewrite)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_split_k_rewrite() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_split_k_rewrite_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_split_k_rewrite(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_split_k_rewrite_ = value;
}

// optional bool xla_gpu_experimental_enable_subchannel_dequantisation_fusion = 368;
inline bool DebugOptions::has_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const {
  bool value = (_impl_._has_bits_[6] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_subchannel_dequantisation_fusion_ = false;
  _impl_._has_bits_[6] &= ~0x00000200u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_subchannel_dequantisation_fusion)
  return _internal_xla_gpu_experimental_enable_subchannel_dequantisation_fusion();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_subchannel_dequantisation_fusion(bool value) {
  _internal_set_xla_gpu_experimental_enable_subchannel_dequantisation_fusion(value);
  _impl_._has_bits_[6] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_subchannel_dequantisation_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_subchannel_dequantisation_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_subchannel_dequantisation_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_subchannel_dequantisation_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_subchannel_dequantisation_fusion_ = value;
}

// optional bool xla_gpu_experimental_enable_triton_heroless_priority_fusion = 340;
inline bool DebugOptions::has_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const {
  bool value = (_impl_._has_bits_[6] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_triton_heroless_priority_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_ = false;
  _impl_._has_bits_[6] &= ~0x00000400u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_triton_heroless_priority_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_triton_heroless_priority_fusion)
  return _internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value) {
  _internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(value);
  _impl_._has_bits_[6] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_triton_heroless_priority_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_ = value;
}

// optional bool xla_gpu_experimental_enable_triton_tma = 355;
inline bool DebugOptions::has_xla_gpu_experimental_enable_triton_tma() const {
  bool value = (_impl_._has_bits_[6] & 0x00000800u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_enable_triton_tma() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_triton_tma_ = false;
  _impl_._has_bits_[6] &= ~0x00000800u;
}
inline bool DebugOptions::xla_gpu_experimental_enable_triton_tma() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_triton_tma)
  return _internal_xla_gpu_experimental_enable_triton_tma();
}
inline void DebugOptions::set_xla_gpu_experimental_enable_triton_tma(bool value) {
  _internal_set_xla_gpu_experimental_enable_triton_tma(value);
  _impl_._has_bits_[6] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_triton_tma)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_enable_triton_tma() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_enable_triton_tma_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_triton_tma(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_enable_triton_tma_ = value;
}

// optional bool xla_gpu_experimental_pack_dot_operands_along_k_dimension = 362;
inline bool DebugOptions::has_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const {
  bool value = (_impl_._has_bits_[6] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_pack_dot_operands_along_k_dimension() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_ = false;
  _impl_._has_bits_[6] &= ~0x00001000u;
}
inline bool DebugOptions::xla_gpu_experimental_pack_dot_operands_along_k_dimension() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_pack_dot_operands_along_k_dimension)
  return _internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension();
}
inline void DebugOptions::set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value) {
  _internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(value);
  _impl_._has_bits_[6] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_pack_dot_operands_along_k_dimension)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_ = value;
}

// optional int32 xla_gpu_experimental_parallel_collective_overlap_limit = 336;
inline bool DebugOptions::has_xla_gpu_experimental_parallel_collective_overlap_limit() const {
  bool value = (_impl_._has_bits_[5] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_parallel_collective_overlap_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_ = 0;
  _impl_._has_bits_[5] &= ~0x01000000u;
}
inline ::int32_t DebugOptions::xla_gpu_experimental_parallel_collective_overlap_limit() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_parallel_collective_overlap_limit)
  return _internal_xla_gpu_experimental_parallel_collective_overlap_limit();
}
inline void DebugOptions::set_xla_gpu_experimental_parallel_collective_overlap_limit(::int32_t value) {
  _internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(value);
  _impl_._has_bits_[5] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_parallel_collective_overlap_limit)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_experimental_parallel_collective_overlap_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_ = value;
}

// optional .xla.DebugOptions.PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level = 351;
inline bool DebugOptions::has_xla_gpu_experimental_pipeline_parallelism_opt_level() const {
  bool value = (_impl_._has_bits_[6] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_pipeline_parallelism_opt_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_ = 0;
  _impl_._has_bits_[6] &= ~0x00000001u;
}
inline ::xla::DebugOptions_PipelineParallelismOptLevel DebugOptions::xla_gpu_experimental_pipeline_parallelism_opt_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_pipeline_parallelism_opt_level)
  return _internal_xla_gpu_experimental_pipeline_parallelism_opt_level();
}
inline void DebugOptions::set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value) {
  _internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(value);
  _impl_._has_bits_[6] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_pipeline_parallelism_opt_level)
}
inline ::xla::DebugOptions_PipelineParallelismOptLevel DebugOptions::_internal_xla_gpu_experimental_pipeline_parallelism_opt_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_PipelineParallelismOptLevel>(_impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_);
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_ = value;
}

// optional bool xla_gpu_experimental_stream_annotation = 342;
inline bool DebugOptions::has_xla_gpu_experimental_stream_annotation() const {
  bool value = (_impl_._has_bits_[5] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_stream_annotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_stream_annotation_ = false;
  _impl_._has_bits_[5] &= ~0x00100000u;
}
inline bool DebugOptions::xla_gpu_experimental_stream_annotation() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_stream_annotation)
  return _internal_xla_gpu_experimental_stream_annotation();
}
inline void DebugOptions::set_xla_gpu_experimental_stream_annotation(bool value) {
  _internal_set_xla_gpu_experimental_stream_annotation(value);
  _impl_._has_bits_[5] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_stream_annotation)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_stream_annotation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_stream_annotation_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_stream_annotation(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_stream_annotation_ = value;
}

// optional bool xla_gpu_experimental_use_autotuner_pass = 396;
inline bool DebugOptions::has_xla_gpu_experimental_use_autotuner_pass() const {
  bool value = (_impl_._has_bits_[5] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_use_autotuner_pass() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_use_autotuner_pass_ = false;
  _impl_._has_bits_[5] &= ~0x00200000u;
}
inline bool DebugOptions::xla_gpu_experimental_use_autotuner_pass() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_use_autotuner_pass)
  return _internal_xla_gpu_experimental_use_autotuner_pass();
}
inline void DebugOptions::set_xla_gpu_experimental_use_autotuner_pass(bool value) {
  _internal_set_xla_gpu_experimental_use_autotuner_pass(value);
  _impl_._has_bits_[5] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_use_autotuner_pass)
}
inline bool DebugOptions::_internal_xla_gpu_experimental_use_autotuner_pass() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_use_autotuner_pass_;
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_use_autotuner_pass(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_use_autotuner_pass_ = value;
}

// optional bool xla_gpu_fail_ptx_compilation_on_register_spilling = 353;
inline bool DebugOptions::has_xla_gpu_fail_ptx_compilation_on_register_spilling() const {
  bool value = (_impl_._has_bits_[5] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_fail_ptx_compilation_on_register_spilling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_ = false;
  _impl_._has_bits_[5] &= ~0x00400000u;
}
inline bool DebugOptions::xla_gpu_fail_ptx_compilation_on_register_spilling() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_fail_ptx_compilation_on_register_spilling)
  return _internal_xla_gpu_fail_ptx_compilation_on_register_spilling();
}
inline void DebugOptions::set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value) {
  _internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(value);
  _impl_._has_bits_[5] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_fail_ptx_compilation_on_register_spilling)
}
inline bool DebugOptions::_internal_xla_gpu_fail_ptx_compilation_on_register_spilling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_;
}
inline void DebugOptions::_internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_ = value;
}

// optional bool xla_gpu_filter_kernels_spilling_registers_on_autotuning = 250;
inline bool DebugOptions::has_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const {
  bool value = (_impl_._has_bits_[5] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_filter_kernels_spilling_registers_on_autotuning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_ = false;
  _impl_._has_bits_[5] &= ~0x00800000u;
}
inline bool DebugOptions::xla_gpu_filter_kernels_spilling_registers_on_autotuning() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_filter_kernels_spilling_registers_on_autotuning)
  return _internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning();
}
inline void DebugOptions::set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value) {
  _internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(value);
  _impl_._has_bits_[5] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_filter_kernels_spilling_registers_on_autotuning)
}
inline bool DebugOptions::_internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_;
}
inline void DebugOptions::_internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_ = value;
}

// optional int32 xla_gpu_first_collective_call_terminate_timeout_seconds = 392;
inline bool DebugOptions::has_xla_gpu_first_collective_call_terminate_timeout_seconds() const {
  bool value = (_impl_._has_bits_[7] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_first_collective_call_terminate_timeout_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_first_collective_call_terminate_timeout_seconds_ = 0;
  _impl_._has_bits_[7] &= ~0x00000008u;
}
inline ::int32_t DebugOptions::xla_gpu_first_collective_call_terminate_timeout_seconds() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_first_collective_call_terminate_timeout_seconds)
  return _internal_xla_gpu_first_collective_call_terminate_timeout_seconds();
}
inline void DebugOptions::set_xla_gpu_first_collective_call_terminate_timeout_seconds(::int32_t value) {
  _internal_set_xla_gpu_first_collective_call_terminate_timeout_seconds(value);
  _impl_._has_bits_[7] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_first_collective_call_terminate_timeout_seconds)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_first_collective_call_terminate_timeout_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_first_collective_call_terminate_timeout_seconds_;
}
inline void DebugOptions::_internal_set_xla_gpu_first_collective_call_terminate_timeout_seconds(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_first_collective_call_terminate_timeout_seconds_ = value;
}

// optional int32 xla_gpu_first_collective_call_warn_stuck_timeout_seconds = 391;
inline bool DebugOptions::has_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const {
  bool value = (_impl_._has_bits_[7] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_first_collective_call_warn_stuck_timeout_seconds_ = 0;
  _impl_._has_bits_[7] &= ~0x00000004u;
}
inline ::int32_t DebugOptions::xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_first_collective_call_warn_stuck_timeout_seconds)
  return _internal_xla_gpu_first_collective_call_warn_stuck_timeout_seconds();
}
inline void DebugOptions::set_xla_gpu_first_collective_call_warn_stuck_timeout_seconds(::int32_t value) {
  _internal_set_xla_gpu_first_collective_call_warn_stuck_timeout_seconds(value);
  _impl_._has_bits_[7] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_first_collective_call_warn_stuck_timeout_seconds)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_first_collective_call_warn_stuck_timeout_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_first_collective_call_warn_stuck_timeout_seconds_;
}
inline void DebugOptions::_internal_set_xla_gpu_first_collective_call_warn_stuck_timeout_seconds(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_first_collective_call_warn_stuck_timeout_seconds_ = value;
}

// optional int32 xla_gpu_force_compilation_parallelism = 147;
inline bool DebugOptions::has_xla_gpu_force_compilation_parallelism() const {
  bool value = (_impl_._has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_force_compilation_parallelism() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_compilation_parallelism_ = 0;
  _impl_._has_bits_[1] &= ~0x01000000u;
}
inline ::int32_t DebugOptions::xla_gpu_force_compilation_parallelism() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_compilation_parallelism)
  return _internal_xla_gpu_force_compilation_parallelism();
}
inline void DebugOptions::set_xla_gpu_force_compilation_parallelism(::int32_t value) {
  _internal_set_xla_gpu_force_compilation_parallelism(value);
  _impl_._has_bits_[1] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_compilation_parallelism)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_force_compilation_parallelism() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_force_compilation_parallelism_;
}
inline void DebugOptions::_internal_set_xla_gpu_force_compilation_parallelism(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_compilation_parallelism_ = value;
}

// optional bool xla_gpu_force_conv_nchw = 125;
inline bool DebugOptions::has_xla_gpu_force_conv_nchw() const {
  bool value = (_impl_._has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_force_conv_nchw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_conv_nchw_ = false;
  _impl_._has_bits_[1] &= ~0x00100000u;
}
inline bool DebugOptions::xla_gpu_force_conv_nchw() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_conv_nchw)
  return _internal_xla_gpu_force_conv_nchw();
}
inline void DebugOptions::set_xla_gpu_force_conv_nchw(bool value) {
  _internal_set_xla_gpu_force_conv_nchw(value);
  _impl_._has_bits_[1] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_conv_nchw)
}
inline bool DebugOptions::_internal_xla_gpu_force_conv_nchw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_force_conv_nchw_;
}
inline void DebugOptions::_internal_set_xla_gpu_force_conv_nchw(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_conv_nchw_ = value;
}

// optional bool xla_gpu_force_conv_nhwc = 146;
inline bool DebugOptions::has_xla_gpu_force_conv_nhwc() const {
  bool value = (_impl_._has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_force_conv_nhwc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_conv_nhwc_ = false;
  _impl_._has_bits_[1] &= ~0x00200000u;
}
inline bool DebugOptions::xla_gpu_force_conv_nhwc() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_conv_nhwc)
  return _internal_xla_gpu_force_conv_nhwc();
}
inline void DebugOptions::set_xla_gpu_force_conv_nhwc(bool value) {
  _internal_set_xla_gpu_force_conv_nhwc(value);
  _impl_._has_bits_[1] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_conv_nhwc)
}
inline bool DebugOptions::_internal_xla_gpu_force_conv_nhwc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_force_conv_nhwc_;
}
inline void DebugOptions::_internal_set_xla_gpu_force_conv_nhwc(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_force_conv_nhwc_ = value;
}

// optional bool xla_gpu_ftz = 62;
inline bool DebugOptions::has_xla_gpu_ftz() const {
  bool value = (_impl_._has_bits_[1] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_ftz() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_ftz_ = false;
  _impl_._has_bits_[1] &= ~0x00400000u;
}
inline bool DebugOptions::xla_gpu_ftz() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_ftz)
  return _internal_xla_gpu_ftz();
}
inline void DebugOptions::set_xla_gpu_ftz(bool value) {
  _internal_set_xla_gpu_ftz(value);
  _impl_._has_bits_[1] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ftz)
}
inline bool DebugOptions::_internal_xla_gpu_ftz() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_ftz_;
}
inline void DebugOptions::_internal_set_xla_gpu_ftz(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_ftz_ = value;
}

// optional bool xla_gpu_fused_attention_use_cudnn_rng = 235;
inline bool DebugOptions::has_xla_gpu_fused_attention_use_cudnn_rng() const {
  bool value = (_impl_._has_bits_[1] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_fused_attention_use_cudnn_rng() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_fused_attention_use_cudnn_rng_ = false;
  _impl_._has_bits_[1] &= ~0x00800000u;
}
inline bool DebugOptions::xla_gpu_fused_attention_use_cudnn_rng() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_fused_attention_use_cudnn_rng)
  return _internal_xla_gpu_fused_attention_use_cudnn_rng();
}
inline void DebugOptions::set_xla_gpu_fused_attention_use_cudnn_rng(bool value) {
  _internal_set_xla_gpu_fused_attention_use_cudnn_rng(value);
  _impl_._has_bits_[1] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_fused_attention_use_cudnn_rng)
}
inline bool DebugOptions::_internal_xla_gpu_fused_attention_use_cudnn_rng() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_fused_attention_use_cudnn_rng_;
}
inline void DebugOptions::_internal_set_xla_gpu_fused_attention_use_cudnn_rng(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_fused_attention_use_cudnn_rng_ = value;
}

// optional int64 xla_gpu_gemm_rewrite_size_threshold = 283;
inline bool DebugOptions::has_xla_gpu_gemm_rewrite_size_threshold() const {
  bool value = (_impl_._has_bits_[4] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_gemm_rewrite_size_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_gemm_rewrite_size_threshold_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00400000u;
}
inline ::int64_t DebugOptions::xla_gpu_gemm_rewrite_size_threshold() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_gemm_rewrite_size_threshold)
  return _internal_xla_gpu_gemm_rewrite_size_threshold();
}
inline void DebugOptions::set_xla_gpu_gemm_rewrite_size_threshold(::int64_t value) {
  _internal_set_xla_gpu_gemm_rewrite_size_threshold(value);
  _impl_._has_bits_[4] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_gemm_rewrite_size_threshold)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_gemm_rewrite_size_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_gemm_rewrite_size_threshold_;
}
inline void DebugOptions::_internal_set_xla_gpu_gemm_rewrite_size_threshold(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_gemm_rewrite_size_threshold_ = value;
}

// optional bool xla_gpu_generate_debug_info = 348;
inline bool DebugOptions::has_xla_gpu_generate_debug_info() const {
  bool value = (_impl_._has_bits_[4] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_generate_debug_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_generate_debug_info_ = false;
  _impl_._has_bits_[4] &= ~0x02000000u;
}
inline bool DebugOptions::xla_gpu_generate_debug_info() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_generate_debug_info)
  return _internal_xla_gpu_generate_debug_info();
}
inline void DebugOptions::set_xla_gpu_generate_debug_info(bool value) {
  _internal_set_xla_gpu_generate_debug_info(value);
  _impl_._has_bits_[4] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_generate_debug_info)
}
inline bool DebugOptions::_internal_xla_gpu_generate_debug_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_generate_debug_info_;
}
inline void DebugOptions::_internal_set_xla_gpu_generate_debug_info(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_generate_debug_info_ = value;
}

// optional bool xla_gpu_generate_line_info = 349;
inline bool DebugOptions::has_xla_gpu_generate_line_info() const {
  bool value = (_impl_._has_bits_[4] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_generate_line_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_generate_line_info_ = false;
  _impl_._has_bits_[4] &= ~0x04000000u;
}
inline bool DebugOptions::xla_gpu_generate_line_info() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_generate_line_info)
  return _internal_xla_gpu_generate_line_info();
}
inline void DebugOptions::set_xla_gpu_generate_line_info(bool value) {
  _internal_set_xla_gpu_generate_line_info(value);
  _impl_._has_bits_[4] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_generate_line_info)
}
inline bool DebugOptions::_internal_xla_gpu_generate_line_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_generate_line_info_;
}
inline void DebugOptions::_internal_set_xla_gpu_generate_line_info(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_generate_line_info_ = value;
}

// optional bool xla_gpu_graph_enable_concurrent_region = 215;
inline bool DebugOptions::has_xla_gpu_graph_enable_concurrent_region() const {
  bool value = (_impl_._has_bits_[4] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_graph_enable_concurrent_region() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_graph_enable_concurrent_region_ = false;
  _impl_._has_bits_[4] &= ~0x08000000u;
}
inline bool DebugOptions::xla_gpu_graph_enable_concurrent_region() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_graph_enable_concurrent_region)
  return _internal_xla_gpu_graph_enable_concurrent_region();
}
inline void DebugOptions::set_xla_gpu_graph_enable_concurrent_region(bool value) {
  _internal_set_xla_gpu_graph_enable_concurrent_region(value);
  _impl_._has_bits_[4] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_graph_enable_concurrent_region)
}
inline bool DebugOptions::_internal_xla_gpu_graph_enable_concurrent_region() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_graph_enable_concurrent_region_;
}
inline void DebugOptions::_internal_set_xla_gpu_graph_enable_concurrent_region(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_graph_enable_concurrent_region_ = value;
}

// optional int32 xla_gpu_graph_min_graph_size = 208;
inline bool DebugOptions::has_xla_gpu_graph_min_graph_size() const {
  bool value = (_impl_._has_bits_[2] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_graph_min_graph_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_graph_min_graph_size_ = 0;
  _impl_._has_bits_[2] &= ~0x01000000u;
}
inline ::int32_t DebugOptions::xla_gpu_graph_min_graph_size() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_graph_min_graph_size)
  return _internal_xla_gpu_graph_min_graph_size();
}
inline void DebugOptions::set_xla_gpu_graph_min_graph_size(::int32_t value) {
  _internal_set_xla_gpu_graph_min_graph_size(value);
  _impl_._has_bits_[2] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_graph_min_graph_size)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_graph_min_graph_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_graph_min_graph_size_;
}
inline void DebugOptions::_internal_set_xla_gpu_graph_min_graph_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_graph_min_graph_size_ = value;
}

// optional string xla_gpu_kernel_cache_file = 306;
inline bool DebugOptions::has_xla_gpu_kernel_cache_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_kernel_cache_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_kernel_cache_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const std::string& DebugOptions::xla_gpu_kernel_cache_file() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_kernel_cache_file)
  return _internal_xla_gpu_kernel_cache_file();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_kernel_cache_file(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.xla_gpu_kernel_cache_file_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_kernel_cache_file)
}
inline std::string* DebugOptions::mutable_xla_gpu_kernel_cache_file() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_kernel_cache_file();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_kernel_cache_file)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_kernel_cache_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_kernel_cache_file_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_kernel_cache_file(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.xla_gpu_kernel_cache_file_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_kernel_cache_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00002000u;
  return _impl_.xla_gpu_kernel_cache_file_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_kernel_cache_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_kernel_cache_file)
  if ((_impl_._has_bits_[0] & 0x00002000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00002000u;
  auto* released = _impl_.xla_gpu_kernel_cache_file_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_kernel_cache_file_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_kernel_cache_file(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.xla_gpu_kernel_cache_file_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_kernel_cache_file_.IsDefault()) {
          _impl_.xla_gpu_kernel_cache_file_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_kernel_cache_file)
}

// optional .xla.DebugOptions.LibNvJitLinkMode xla_gpu_libnvjitlink_mode = 343;
inline bool DebugOptions::has_xla_gpu_libnvjitlink_mode() const {
  bool value = (_impl_._has_bits_[5] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_libnvjitlink_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_libnvjitlink_mode_ = 0;
  _impl_._has_bits_[5] &= ~0x80000000u;
}
inline ::xla::DebugOptions_LibNvJitLinkMode DebugOptions::xla_gpu_libnvjitlink_mode() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_libnvjitlink_mode)
  return _internal_xla_gpu_libnvjitlink_mode();
}
inline void DebugOptions::set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value) {
  _internal_set_xla_gpu_libnvjitlink_mode(value);
  _impl_._has_bits_[5] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_libnvjitlink_mode)
}
inline ::xla::DebugOptions_LibNvJitLinkMode DebugOptions::_internal_xla_gpu_libnvjitlink_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_LibNvJitLinkMode>(_impl_.xla_gpu_libnvjitlink_mode_);
}
inline void DebugOptions::_internal_set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_libnvjitlink_mode_ = value;
}

// repeated string xla_gpu_llvm_ir_file = 150;
inline int DebugOptions::_internal_xla_gpu_llvm_ir_file_size() const {
  return _internal_xla_gpu_llvm_ir_file().size();
}
inline int DebugOptions::xla_gpu_llvm_ir_file_size() const {
  return _internal_xla_gpu_llvm_ir_file_size();
}
inline void DebugOptions::clear_xla_gpu_llvm_ir_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_llvm_ir_file_.Clear();
}
inline std::string* DebugOptions::add_xla_gpu_llvm_ir_file() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_xla_gpu_llvm_ir_file()->Add();
  // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_gpu_llvm_ir_file)
  return _s;
}
inline const std::string& DebugOptions::xla_gpu_llvm_ir_file(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_llvm_ir_file)
  return _internal_xla_gpu_llvm_ir_file().Get(index);
}
inline std::string* DebugOptions::mutable_xla_gpu_llvm_ir_file(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_llvm_ir_file)
  return _internal_mutable_xla_gpu_llvm_ir_file()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::set_xla_gpu_llvm_ir_file(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_xla_gpu_llvm_ir_file()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_llvm_ir_file)
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::add_xla_gpu_llvm_ir_file(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_xla_gpu_llvm_ir_file(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_llvm_ir_file)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::xla_gpu_llvm_ir_file() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_llvm_ir_file)
  return _internal_xla_gpu_llvm_ir_file();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::mutable_xla_gpu_llvm_ir_file() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_llvm_ir_file)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_gpu_llvm_ir_file();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::_internal_xla_gpu_llvm_ir_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_llvm_ir_file_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::_internal_mutable_xla_gpu_llvm_ir_file() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_gpu_llvm_ir_file_;
}

// optional int32 xla_gpu_llvm_verification_level = 256;
inline bool DebugOptions::has_xla_gpu_llvm_verification_level() const {
  bool value = (_impl_._has_bits_[4] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_llvm_verification_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_llvm_verification_level_ = 0;
  _impl_._has_bits_[4] &= ~0x00000100u;
}
inline ::int32_t DebugOptions::xla_gpu_llvm_verification_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_llvm_verification_level)
  return _internal_xla_gpu_llvm_verification_level();
}
inline void DebugOptions::set_xla_gpu_llvm_verification_level(::int32_t value) {
  _internal_set_xla_gpu_llvm_verification_level(value);
  _impl_._has_bits_[4] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_llvm_verification_level)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_llvm_verification_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_llvm_verification_level_;
}
inline void DebugOptions::_internal_set_xla_gpu_llvm_verification_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_llvm_verification_level_ = value;
}

// optional string xla_gpu_load_autotune_results_from = 223;
inline bool DebugOptions::has_xla_gpu_load_autotune_results_from() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_load_autotune_results_from() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_load_autotune_results_from_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& DebugOptions::xla_gpu_load_autotune_results_from() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_load_autotune_results_from)
  return _internal_xla_gpu_load_autotune_results_from();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_load_autotune_results_from(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.xla_gpu_load_autotune_results_from_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_load_autotune_results_from)
}
inline std::string* DebugOptions::mutable_xla_gpu_load_autotune_results_from() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_load_autotune_results_from();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_load_autotune_results_from)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_load_autotune_results_from() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_load_autotune_results_from_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_load_autotune_results_from(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.xla_gpu_load_autotune_results_from_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_load_autotune_results_from() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.xla_gpu_load_autotune_results_from_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_load_autotune_results_from() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_load_autotune_results_from)
  if ((_impl_._has_bits_[0] & 0x00000100u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* released = _impl_.xla_gpu_load_autotune_results_from_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_load_autotune_results_from_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_load_autotune_results_from(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.xla_gpu_load_autotune_results_from_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_load_autotune_results_from_.IsDefault()) {
          _impl_.xla_gpu_load_autotune_results_from_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_load_autotune_results_from)
}

// optional int32 xla_gpu_memory_limit_slop_factor = 260;
inline bool DebugOptions::has_xla_gpu_memory_limit_slop_factor() const {
  bool value = (_impl_._has_bits_[4] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_memory_limit_slop_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_memory_limit_slop_factor_ = 0;
  _impl_._has_bits_[4] &= ~0x00000200u;
}
inline ::int32_t DebugOptions::xla_gpu_memory_limit_slop_factor() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_memory_limit_slop_factor)
  return _internal_xla_gpu_memory_limit_slop_factor();
}
inline void DebugOptions::set_xla_gpu_memory_limit_slop_factor(::int32_t value) {
  _internal_set_xla_gpu_memory_limit_slop_factor(value);
  _impl_._has_bits_[4] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_memory_limit_slop_factor)
}
inline ::int32_t DebugOptions::_internal_xla_gpu_memory_limit_slop_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_memory_limit_slop_factor_;
}
inline void DebugOptions::_internal_set_xla_gpu_memory_limit_slop_factor(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_memory_limit_slop_factor_ = value;
}

// optional bool xla_gpu_mock_custom_calls = 245;
inline bool DebugOptions::has_xla_gpu_mock_custom_calls() const {
  bool value = (_impl_._has_bits_[4] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_mock_custom_calls() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_mock_custom_calls_ = false;
  _impl_._has_bits_[4] &= ~0x10000000u;
}
inline bool DebugOptions::xla_gpu_mock_custom_calls() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_mock_custom_calls)
  return _internal_xla_gpu_mock_custom_calls();
}
inline void DebugOptions::set_xla_gpu_mock_custom_calls(bool value) {
  _internal_set_xla_gpu_mock_custom_calls(value);
  _impl_._has_bits_[4] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_mock_custom_calls)
}
inline bool DebugOptions::_internal_xla_gpu_mock_custom_calls() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_mock_custom_calls_;
}
inline void DebugOptions::_internal_set_xla_gpu_mock_custom_calls(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_mock_custom_calls_ = value;
}

// optional bool xla_gpu_multi_streamed_windowed_einsum = 280;
inline bool DebugOptions::has_xla_gpu_multi_streamed_windowed_einsum() const {
  bool value = (_impl_._has_bits_[5] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_multi_streamed_windowed_einsum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_multi_streamed_windowed_einsum_ = false;
  _impl_._has_bits_[5] &= ~0x08000000u;
}
inline bool DebugOptions::xla_gpu_multi_streamed_windowed_einsum() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_multi_streamed_windowed_einsum)
  return _internal_xla_gpu_multi_streamed_windowed_einsum();
}
inline void DebugOptions::set_xla_gpu_multi_streamed_windowed_einsum(bool value) {
  _internal_set_xla_gpu_multi_streamed_windowed_einsum(value);
  _impl_._has_bits_[5] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_multi_streamed_windowed_einsum)
}
inline bool DebugOptions::_internal_xla_gpu_multi_streamed_windowed_einsum() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_multi_streamed_windowed_einsum_;
}
inline void DebugOptions::_internal_set_xla_gpu_multi_streamed_windowed_einsum(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_multi_streamed_windowed_einsum_ = value;
}

// optional bool xla_gpu_nccl_async_execution = 393;
inline bool DebugOptions::has_xla_gpu_nccl_async_execution() const {
  bool value = (_impl_._has_bits_[5] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_async_execution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_async_execution_ = false;
  _impl_._has_bits_[5] &= ~0x10000000u;
}
inline bool DebugOptions::xla_gpu_nccl_async_execution() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_async_execution)
  return _internal_xla_gpu_nccl_async_execution();
}
inline void DebugOptions::set_xla_gpu_nccl_async_execution(bool value) {
  _internal_set_xla_gpu_nccl_async_execution(value);
  _impl_._has_bits_[5] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_async_execution)
}
inline bool DebugOptions::_internal_xla_gpu_nccl_async_execution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_async_execution_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_async_execution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_async_execution_ = value;
}

// optional bool xla_gpu_nccl_blocking_communicators = 390;
inline bool DebugOptions::has_xla_gpu_nccl_blocking_communicators() const {
  bool value = (_impl_._has_bits_[5] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_blocking_communicators() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_blocking_communicators_ = false;
  _impl_._has_bits_[5] &= ~0x20000000u;
}
inline bool DebugOptions::xla_gpu_nccl_blocking_communicators() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_blocking_communicators)
  return _internal_xla_gpu_nccl_blocking_communicators();
}
inline void DebugOptions::set_xla_gpu_nccl_blocking_communicators(bool value) {
  _internal_set_xla_gpu_nccl_blocking_communicators(value);
  _impl_._has_bits_[5] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_blocking_communicators)
}
inline bool DebugOptions::_internal_xla_gpu_nccl_blocking_communicators() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_blocking_communicators_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_blocking_communicators(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_blocking_communicators_ = value;
}

// optional int64 xla_gpu_nccl_collective_max_nchannels = 273;
inline bool DebugOptions::has_xla_gpu_nccl_collective_max_nchannels() const {
  bool value = (_impl_._has_bits_[4] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_collective_max_nchannels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_collective_max_nchannels_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00080000u;
}
inline ::int64_t DebugOptions::xla_gpu_nccl_collective_max_nchannels() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_collective_max_nchannels)
  return _internal_xla_gpu_nccl_collective_max_nchannels();
}
inline void DebugOptions::set_xla_gpu_nccl_collective_max_nchannels(::int64_t value) {
  _internal_set_xla_gpu_nccl_collective_max_nchannels(value);
  _impl_._has_bits_[4] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_collective_max_nchannels)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_nccl_collective_max_nchannels() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_collective_max_nchannels_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_collective_max_nchannels(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_collective_max_nchannels_ = value;
}

// optional int64 xla_gpu_nccl_init_max_rank_per_root_ratio = 277;
inline bool DebugOptions::has_xla_gpu_nccl_init_max_rank_per_root_ratio() const {
  bool value = (_impl_._has_bits_[4] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_init_max_rank_per_root_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00200000u;
}
inline ::int64_t DebugOptions::xla_gpu_nccl_init_max_rank_per_root_ratio() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_init_max_rank_per_root_ratio)
  return _internal_xla_gpu_nccl_init_max_rank_per_root_ratio();
}
inline void DebugOptions::set_xla_gpu_nccl_init_max_rank_per_root_ratio(::int64_t value) {
  _internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(value);
  _impl_._has_bits_[4] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_init_max_rank_per_root_ratio)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_nccl_init_max_rank_per_root_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_ = value;
}

// optional int64 xla_gpu_nccl_p2p_max_nchannels = 274;
inline bool DebugOptions::has_xla_gpu_nccl_p2p_max_nchannels() const {
  bool value = (_impl_._has_bits_[4] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_p2p_max_nchannels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_p2p_max_nchannels_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00100000u;
}
inline ::int64_t DebugOptions::xla_gpu_nccl_p2p_max_nchannels() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_p2p_max_nchannels)
  return _internal_xla_gpu_nccl_p2p_max_nchannels();
}
inline void DebugOptions::set_xla_gpu_nccl_p2p_max_nchannels(::int64_t value) {
  _internal_set_xla_gpu_nccl_p2p_max_nchannels(value);
  _impl_._has_bits_[4] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_p2p_max_nchannels)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_nccl_p2p_max_nchannels() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_p2p_max_nchannels_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_p2p_max_nchannels(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_p2p_max_nchannels_ = value;
}

// optional bool xla_gpu_nccl_terminate_on_error = 301;
inline bool DebugOptions::has_xla_gpu_nccl_terminate_on_error() const {
  bool value = (_impl_._has_bits_[5] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_terminate_on_error() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_terminate_on_error_ = false;
  _impl_._has_bits_[5] &= ~0x40000000u;
}
inline bool DebugOptions::xla_gpu_nccl_terminate_on_error() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_terminate_on_error)
  return _internal_xla_gpu_nccl_terminate_on_error();
}
inline void DebugOptions::set_xla_gpu_nccl_terminate_on_error(bool value) {
  _internal_set_xla_gpu_nccl_terminate_on_error(value);
  _impl_._has_bits_[5] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_terminate_on_error)
}
inline bool DebugOptions::_internal_xla_gpu_nccl_terminate_on_error() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_terminate_on_error_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_terminate_on_error(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_terminate_on_error_ = value;
}

// optional int64 xla_gpu_nccl_termination_timeout_seconds = 163;
inline bool DebugOptions::has_xla_gpu_nccl_termination_timeout_seconds() const {
  bool value = (_impl_._has_bits_[2] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_nccl_termination_timeout_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_termination_timeout_seconds_ = ::int64_t{0};
  _impl_._has_bits_[2] &= ~0x00000001u;
}
inline ::int64_t DebugOptions::xla_gpu_nccl_termination_timeout_seconds() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_termination_timeout_seconds)
  return _internal_xla_gpu_nccl_termination_timeout_seconds();
}
inline void DebugOptions::set_xla_gpu_nccl_termination_timeout_seconds(::int64_t value) {
  _internal_set_xla_gpu_nccl_termination_timeout_seconds(value);
  _impl_._has_bits_[2] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_termination_timeout_seconds)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_nccl_termination_timeout_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_nccl_termination_timeout_seconds_;
}
inline void DebugOptions::_internal_set_xla_gpu_nccl_termination_timeout_seconds(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_nccl_termination_timeout_seconds_ = value;
}

// optional int64 xla_gpu_operand_bytes_threshold_for_windowed_einsum = 339;
inline bool DebugOptions::has_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const {
  bool value = (_impl_._has_bits_[5] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_operand_bytes_threshold_for_windowed_einsum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_ = ::int64_t{0};
  _impl_._has_bits_[5] &= ~0x02000000u;
}
inline ::int64_t DebugOptions::xla_gpu_operand_bytes_threshold_for_windowed_einsum() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_operand_bytes_threshold_for_windowed_einsum)
  return _internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum();
}
inline void DebugOptions::set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(::int64_t value) {
  _internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(value);
  _impl_._has_bits_[5] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_operand_bytes_threshold_for_windowed_einsum)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_;
}
inline void DebugOptions::_internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_ = value;
}

// optional string xla_gpu_override_gemm_autotuner = 295;
inline bool DebugOptions::has_xla_gpu_override_gemm_autotuner() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_override_gemm_autotuner() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_override_gemm_autotuner_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& DebugOptions::xla_gpu_override_gemm_autotuner() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_override_gemm_autotuner)
  return _internal_xla_gpu_override_gemm_autotuner();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_override_gemm_autotuner(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.xla_gpu_override_gemm_autotuner_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_override_gemm_autotuner)
}
inline std::string* DebugOptions::mutable_xla_gpu_override_gemm_autotuner() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_override_gemm_autotuner();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_override_gemm_autotuner)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_override_gemm_autotuner() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_override_gemm_autotuner_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_override_gemm_autotuner(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.xla_gpu_override_gemm_autotuner_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_override_gemm_autotuner() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.xla_gpu_override_gemm_autotuner_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_override_gemm_autotuner() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_override_gemm_autotuner)
  if ((_impl_._has_bits_[0] & 0x00001000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  auto* released = _impl_.xla_gpu_override_gemm_autotuner_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_override_gemm_autotuner_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_override_gemm_autotuner(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.xla_gpu_override_gemm_autotuner_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_override_gemm_autotuner_.IsDefault()) {
          _impl_.xla_gpu_override_gemm_autotuner_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_override_gemm_autotuner)
}

// optional string xla_gpu_per_fusion_autotune_cache_dir = 310;
inline bool DebugOptions::has_xla_gpu_per_fusion_autotune_cache_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_per_fusion_autotune_cache_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_per_fusion_autotune_cache_dir_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const std::string& DebugOptions::xla_gpu_per_fusion_autotune_cache_dir() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir)
  return _internal_xla_gpu_per_fusion_autotune_cache_dir();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_per_fusion_autotune_cache_dir(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir)
}
inline std::string* DebugOptions::mutable_xla_gpu_per_fusion_autotune_cache_dir() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_per_fusion_autotune_cache_dir();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_per_fusion_autotune_cache_dir() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_per_fusion_autotune_cache_dir(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_per_fusion_autotune_cache_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00004000u;
  return _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_per_fusion_autotune_cache_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir)
  if ((_impl_._has_bits_[0] & 0x00004000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00004000u;
  auto* released = _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_per_fusion_autotune_cache_dir(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.xla_gpu_per_fusion_autotune_cache_dir_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_per_fusion_autotune_cache_dir_.IsDefault()) {
          _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir)
}

// optional .xla.DebugOptions.PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker = 341;
inline bool DebugOptions::has_xla_gpu_pgle_accuracy_checker() const {
  bool value = (_impl_._has_bits_[5] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_pgle_accuracy_checker() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_pgle_accuracy_checker_ = 0;
  _impl_._has_bits_[5] &= ~0x04000000u;
}
inline ::xla::DebugOptions_PGLEStrictnessLevel DebugOptions::xla_gpu_pgle_accuracy_checker() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_pgle_accuracy_checker)
  return _internal_xla_gpu_pgle_accuracy_checker();
}
inline void DebugOptions::set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value) {
  _internal_set_xla_gpu_pgle_accuracy_checker(value);
  _impl_._has_bits_[5] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_pgle_accuracy_checker)
}
inline ::xla::DebugOptions_PGLEStrictnessLevel DebugOptions::_internal_xla_gpu_pgle_accuracy_checker() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_PGLEStrictnessLevel>(_impl_.xla_gpu_pgle_accuracy_checker_);
}
inline void DebugOptions::_internal_set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_pgle_accuracy_checker_ = value;
}

// optional string xla_gpu_pgle_profile_file_or_directory_path = 210;
inline bool DebugOptions::has_xla_gpu_pgle_profile_file_or_directory_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_pgle_profile_file_or_directory_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_pgle_profile_file_or_directory_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& DebugOptions::xla_gpu_pgle_profile_file_or_directory_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path)
  return _internal_xla_gpu_pgle_profile_file_or_directory_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_pgle_profile_file_or_directory_path(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path)
}
inline std::string* DebugOptions::mutable_xla_gpu_pgle_profile_file_or_directory_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_pgle_profile_file_or_directory_path();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_pgle_profile_file_or_directory_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_pgle_profile_file_or_directory_path(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_pgle_profile_file_or_directory_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_pgle_profile_file_or_directory_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path)
  if ((_impl_._has_bits_[0] & 0x00000040u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* released = _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_pgle_profile_file_or_directory_path(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.xla_gpu_pgle_profile_file_or_directory_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_pgle_profile_file_or_directory_path_.IsDefault()) {
          _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path)
}

// repeated string xla_gpu_ptx_file = 127;
inline int DebugOptions::_internal_xla_gpu_ptx_file_size() const {
  return _internal_xla_gpu_ptx_file().size();
}
inline int DebugOptions::xla_gpu_ptx_file_size() const {
  return _internal_xla_gpu_ptx_file_size();
}
inline void DebugOptions::clear_xla_gpu_ptx_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_ptx_file_.Clear();
}
inline std::string* DebugOptions::add_xla_gpu_ptx_file() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_xla_gpu_ptx_file()->Add();
  // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_gpu_ptx_file)
  return _s;
}
inline const std::string& DebugOptions::xla_gpu_ptx_file(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_ptx_file)
  return _internal_xla_gpu_ptx_file().Get(index);
}
inline std::string* DebugOptions::mutable_xla_gpu_ptx_file(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_ptx_file)
  return _internal_mutable_xla_gpu_ptx_file()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::set_xla_gpu_ptx_file(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_xla_gpu_ptx_file()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ptx_file)
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::add_xla_gpu_ptx_file(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_xla_gpu_ptx_file(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_ptx_file)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::xla_gpu_ptx_file() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_ptx_file)
  return _internal_xla_gpu_ptx_file();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::mutable_xla_gpu_ptx_file() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_ptx_file)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_gpu_ptx_file();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::_internal_xla_gpu_ptx_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_ptx_file_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::_internal_mutable_xla_gpu_ptx_file() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_gpu_ptx_file_;
}

// optional int64 xla_gpu_reduce_scatter_combine_threshold_bytes = 213;
inline bool DebugOptions::has_xla_gpu_reduce_scatter_combine_threshold_bytes() const {
  bool value = (_impl_._has_bits_[3] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_reduce_scatter_combine_threshold_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_ = ::int64_t{0};
  _impl_._has_bits_[3] &= ~0x00000004u;
}
inline ::int64_t DebugOptions::xla_gpu_reduce_scatter_combine_threshold_bytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_reduce_scatter_combine_threshold_bytes)
  return _internal_xla_gpu_reduce_scatter_combine_threshold_bytes();
}
inline void DebugOptions::set_xla_gpu_reduce_scatter_combine_threshold_bytes(::int64_t value) {
  _internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(value);
  _impl_._has_bits_[3] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_reduce_scatter_combine_threshold_bytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_reduce_scatter_combine_threshold_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_ = value;
}

// optional int64 xla_gpu_redzone_padding_bytes = 228;
inline bool DebugOptions::has_xla_gpu_redzone_padding_bytes() const {
  bool value = (_impl_._has_bits_[3] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_redzone_padding_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_redzone_padding_bytes_ = ::int64_t{0};
  _impl_._has_bits_[3] &= ~0x00002000u;
}
inline ::int64_t DebugOptions::xla_gpu_redzone_padding_bytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_redzone_padding_bytes)
  return _internal_xla_gpu_redzone_padding_bytes();
}
inline void DebugOptions::set_xla_gpu_redzone_padding_bytes(::int64_t value) {
  _internal_set_xla_gpu_redzone_padding_bytes(value);
  _impl_._has_bits_[3] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_redzone_padding_bytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_redzone_padding_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_redzone_padding_bytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_redzone_padding_bytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_redzone_padding_bytes_ = value;
}

// optional int64 xla_gpu_redzone_scratch_max_megabytes = 167;
inline bool DebugOptions::has_xla_gpu_redzone_scratch_max_megabytes() const {
  bool value = (_impl_._has_bits_[2] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_redzone_scratch_max_megabytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_redzone_scratch_max_megabytes_ = ::int64_t{0};
  _impl_._has_bits_[2] &= ~0x00000002u;
}
inline ::int64_t DebugOptions::xla_gpu_redzone_scratch_max_megabytes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_redzone_scratch_max_megabytes)
  return _internal_xla_gpu_redzone_scratch_max_megabytes();
}
inline void DebugOptions::set_xla_gpu_redzone_scratch_max_megabytes(::int64_t value) {
  _internal_set_xla_gpu_redzone_scratch_max_megabytes(value);
  _impl_._has_bits_[2] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_redzone_scratch_max_megabytes)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_redzone_scratch_max_megabytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_redzone_scratch_max_megabytes_;
}
inline void DebugOptions::_internal_set_xla_gpu_redzone_scratch_max_megabytes(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_redzone_scratch_max_megabytes_ = value;
}

// optional bool xla_gpu_require_complete_aot_autotune_results = 284;
inline bool DebugOptions::has_xla_gpu_require_complete_aot_autotune_results() const {
  bool value = (_impl_._has_bits_[4] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_require_complete_aot_autotune_results() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_require_complete_aot_autotune_results_ = false;
  _impl_._has_bits_[4] &= ~0x00008000u;
}
inline bool DebugOptions::xla_gpu_require_complete_aot_autotune_results() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_require_complete_aot_autotune_results)
  return _internal_xla_gpu_require_complete_aot_autotune_results();
}
inline void DebugOptions::set_xla_gpu_require_complete_aot_autotune_results(bool value) {
  _internal_set_xla_gpu_require_complete_aot_autotune_results(value);
  _impl_._has_bits_[4] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_require_complete_aot_autotune_results)
}
inline bool DebugOptions::_internal_xla_gpu_require_complete_aot_autotune_results() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_require_complete_aot_autotune_results_;
}
inline void DebugOptions::_internal_set_xla_gpu_require_complete_aot_autotune_results(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_require_complete_aot_autotune_results_ = value;
}

// optional bool xla_gpu_require_exclusive_lock = 347;
inline bool DebugOptions::has_xla_gpu_require_exclusive_lock() const {
  bool value = (_impl_._has_bits_[4] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_require_exclusive_lock() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_require_exclusive_lock_ = false;
  _impl_._has_bits_[4] &= ~0x00010000u;
}
inline bool DebugOptions::xla_gpu_require_exclusive_lock() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_require_exclusive_lock)
  return _internal_xla_gpu_require_exclusive_lock();
}
inline void DebugOptions::set_xla_gpu_require_exclusive_lock(bool value) {
  _internal_set_xla_gpu_require_exclusive_lock(value);
  _impl_._has_bits_[4] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_require_exclusive_lock)
}
inline bool DebugOptions::_internal_xla_gpu_require_exclusive_lock() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_require_exclusive_lock_;
}
inline void DebugOptions::_internal_set_xla_gpu_require_exclusive_lock(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_require_exclusive_lock_ = value;
}

// optional .xla.DebugOptions.ShapeChecks xla_gpu_shape_checks = 170;
inline bool DebugOptions::has_xla_gpu_shape_checks() const {
  bool value = (_impl_._has_bits_[1] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_shape_checks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_shape_checks_ = 0;
  _impl_._has_bits_[1] &= ~0x80000000u;
}
inline ::xla::DebugOptions_ShapeChecks DebugOptions::xla_gpu_shape_checks() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_shape_checks)
  return _internal_xla_gpu_shape_checks();
}
inline void DebugOptions::set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value) {
  _internal_set_xla_gpu_shape_checks(value);
  _impl_._has_bits_[1] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_shape_checks)
}
inline ::xla::DebugOptions_ShapeChecks DebugOptions::_internal_xla_gpu_shape_checks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_ShapeChecks>(_impl_.xla_gpu_shape_checks_);
}
inline void DebugOptions::_internal_set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_shape_checks_ = value;
}

// optional bool xla_gpu_shard_autotuning = 304;
inline bool DebugOptions::has_xla_gpu_shard_autotuning() const {
  bool value = (_impl_._has_bits_[4] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_shard_autotuning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_shard_autotuning_ = false;
  _impl_._has_bits_[4] &= ~0x00020000u;
}
inline bool DebugOptions::xla_gpu_shard_autotuning() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_shard_autotuning)
  return _internal_xla_gpu_shard_autotuning();
}
inline void DebugOptions::set_xla_gpu_shard_autotuning(bool value) {
  _internal_set_xla_gpu_shard_autotuning(value);
  _impl_._has_bits_[4] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_shard_autotuning)
}
inline bool DebugOptions::_internal_xla_gpu_shard_autotuning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_shard_autotuning_;
}
inline void DebugOptions::_internal_set_xla_gpu_shard_autotuning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_shard_autotuning_ = value;
}

// optional bool xla_gpu_strict_conv_algorithm_picker = 156;
inline bool DebugOptions::has_xla_gpu_strict_conv_algorithm_picker() const {
  bool value = (_impl_._has_bits_[4] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_strict_conv_algorithm_picker() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_strict_conv_algorithm_picker_ = false;
  _impl_._has_bits_[4] &= ~0x00040000u;
}
inline bool DebugOptions::xla_gpu_strict_conv_algorithm_picker() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_strict_conv_algorithm_picker)
  return _internal_xla_gpu_strict_conv_algorithm_picker();
}
inline void DebugOptions::set_xla_gpu_strict_conv_algorithm_picker(bool value) {
  _internal_set_xla_gpu_strict_conv_algorithm_picker(value);
  _impl_._has_bits_[4] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_strict_conv_algorithm_picker)
}
inline bool DebugOptions::_internal_xla_gpu_strict_conv_algorithm_picker() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_strict_conv_algorithm_picker_;
}
inline void DebugOptions::_internal_set_xla_gpu_strict_conv_algorithm_picker(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_strict_conv_algorithm_picker_ = value;
}

// optional string xla_gpu_target_config_filename = 261;
inline bool DebugOptions::has_xla_gpu_target_config_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_target_config_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_target_config_filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& DebugOptions::xla_gpu_target_config_filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_target_config_filename)
  return _internal_xla_gpu_target_config_filename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_target_config_filename(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.xla_gpu_target_config_filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_target_config_filename)
}
inline std::string* DebugOptions::mutable_xla_gpu_target_config_filename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_target_config_filename();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_target_config_filename)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_target_config_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_target_config_filename_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_target_config_filename(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.xla_gpu_target_config_filename_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_target_config_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.xla_gpu_target_config_filename_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_target_config_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_target_config_filename)
  if ((_impl_._has_bits_[0] & 0x00000200u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* released = _impl_.xla_gpu_target_config_filename_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_target_config_filename_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_target_config_filename(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.xla_gpu_target_config_filename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_target_config_filename_.IsDefault()) {
          _impl_.xla_gpu_target_config_filename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_target_config_filename)
}

// optional bool xla_gpu_temp_buffer_use_separate_color = 312;
inline bool DebugOptions::has_xla_gpu_temp_buffer_use_separate_color() const {
  bool value = (_impl_._has_bits_[3] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_temp_buffer_use_separate_color() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_temp_buffer_use_separate_color_ = false;
  _impl_._has_bits_[3] &= ~0x08000000u;
}
inline bool DebugOptions::xla_gpu_temp_buffer_use_separate_color() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_temp_buffer_use_separate_color)
  return _internal_xla_gpu_temp_buffer_use_separate_color();
}
inline void DebugOptions::set_xla_gpu_temp_buffer_use_separate_color(bool value) {
  _internal_set_xla_gpu_temp_buffer_use_separate_color(value);
  _impl_._has_bits_[3] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_temp_buffer_use_separate_color)
}
inline bool DebugOptions::_internal_xla_gpu_temp_buffer_use_separate_color() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_temp_buffer_use_separate_color_;
}
inline void DebugOptions::_internal_set_xla_gpu_temp_buffer_use_separate_color(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_temp_buffer_use_separate_color_ = value;
}

// optional int64 xla_gpu_threshold_for_windowed_einsum_mib = 265;
inline bool DebugOptions::has_xla_gpu_threshold_for_windowed_einsum_mib() const {
  bool value = (_impl_._has_bits_[4] & 0x00000400u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_threshold_for_windowed_einsum_mib() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_threshold_for_windowed_einsum_mib_ = ::int64_t{0};
  _impl_._has_bits_[4] &= ~0x00000400u;
}
inline ::int64_t DebugOptions::xla_gpu_threshold_for_windowed_einsum_mib() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_threshold_for_windowed_einsum_mib)
  return _internal_xla_gpu_threshold_for_windowed_einsum_mib();
}
inline void DebugOptions::set_xla_gpu_threshold_for_windowed_einsum_mib(::int64_t value) {
  _internal_set_xla_gpu_threshold_for_windowed_einsum_mib(value);
  _impl_._has_bits_[4] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_threshold_for_windowed_einsum_mib)
}
inline ::int64_t DebugOptions::_internal_xla_gpu_threshold_for_windowed_einsum_mib() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_threshold_for_windowed_einsum_mib_;
}
inline void DebugOptions::_internal_set_xla_gpu_threshold_for_windowed_einsum_mib(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_threshold_for_windowed_einsum_mib_ = value;
}

// optional bool xla_gpu_triton_gemm_any = 190;
inline bool DebugOptions::has_xla_gpu_triton_gemm_any() const {
  bool value = (_impl_._has_bits_[3] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_triton_gemm_any() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_triton_gemm_any_ = false;
  _impl_._has_bits_[3] &= ~0x10000000u;
}
inline bool DebugOptions::xla_gpu_triton_gemm_any() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_triton_gemm_any)
  return _internal_xla_gpu_triton_gemm_any();
}
inline void DebugOptions::set_xla_gpu_triton_gemm_any(bool value) {
  _internal_set_xla_gpu_triton_gemm_any(value);
  _impl_._has_bits_[3] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_triton_gemm_any)
}
inline bool DebugOptions::_internal_xla_gpu_triton_gemm_any() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_triton_gemm_any_;
}
inline void DebugOptions::_internal_set_xla_gpu_triton_gemm_any(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_triton_gemm_any_ = value;
}

// optional bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found = 138;
inline bool DebugOptions::has_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const {
  bool value = (_impl_._has_bits_[3] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_ = false;
  _impl_._has_bits_[3] &= ~0x20000000u;
}
inline bool DebugOptions::xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found)
  return _internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found();
}
inline void DebugOptions::set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value) {
  _internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(value);
  _impl_._has_bits_[3] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found)
}
inline bool DebugOptions::_internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_ = value;
}

// optional bool xla_gpu_unsupported_annotate_with_emitter_loc = 358;
inline bool DebugOptions::has_xla_gpu_unsupported_annotate_with_emitter_loc() const {
  bool value = (_impl_._has_bits_[3] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_annotate_with_emitter_loc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_ = false;
  _impl_._has_bits_[3] &= ~0x40000000u;
}
inline bool DebugOptions::xla_gpu_unsupported_annotate_with_emitter_loc() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_annotate_with_emitter_loc)
  return _internal_xla_gpu_unsupported_annotate_with_emitter_loc();
}
inline void DebugOptions::set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value) {
  _internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(value);
  _impl_._has_bits_[3] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_annotate_with_emitter_loc)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_annotate_with_emitter_loc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_ = value;
}

// optional bool xla_gpu_unsupported_enable_all_reduce_decomposer = 384;
inline bool DebugOptions::has_xla_gpu_unsupported_enable_all_reduce_decomposer() const {
  bool value = (_impl_._has_bits_[6] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_enable_all_reduce_decomposer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_all_reduce_decomposer_ = false;
  _impl_._has_bits_[6] &= ~0x00002000u;
}
inline bool DebugOptions::xla_gpu_unsupported_enable_all_reduce_decomposer() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_all_reduce_decomposer)
  return _internal_xla_gpu_unsupported_enable_all_reduce_decomposer();
}
inline void DebugOptions::set_xla_gpu_unsupported_enable_all_reduce_decomposer(bool value) {
  _internal_set_xla_gpu_unsupported_enable_all_reduce_decomposer(value);
  _impl_._has_bits_[6] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_all_reduce_decomposer)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_all_reduce_decomposer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_enable_all_reduce_decomposer_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_all_reduce_decomposer(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_all_reduce_decomposer_ = value;
}

// optional bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer = 350;
inline bool DebugOptions::has_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const {
  bool value = (_impl_._has_bits_[6] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_ = false;
  _impl_._has_bits_[6] &= ~0x00004000u;
}
inline bool DebugOptions::xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer)
  return _internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer();
}
inline void DebugOptions::set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value) {
  _internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(value);
  _impl_._has_bits_[6] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_ = value;
}

// optional bool xla_gpu_unsupported_enable_triton_gemm = 322;
inline bool DebugOptions::has_xla_gpu_unsupported_enable_triton_gemm() const {
  bool value = (_impl_._has_bits_[6] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_enable_triton_gemm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_triton_gemm_ = false;
  _impl_._has_bits_[6] &= ~0x00008000u;
}
inline bool DebugOptions::xla_gpu_unsupported_enable_triton_gemm() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_triton_gemm)
  return _internal_xla_gpu_unsupported_enable_triton_gemm();
}
inline void DebugOptions::set_xla_gpu_unsupported_enable_triton_gemm(bool value) {
  _internal_set_xla_gpu_unsupported_enable_triton_gemm(value);
  _impl_._has_bits_[6] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_triton_gemm)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_triton_gemm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_enable_triton_gemm_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_triton_gemm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_triton_gemm_ = value;
}

// optional bool xla_gpu_unsupported_enable_triton_multi_output_fusion = 382;
inline bool DebugOptions::has_xla_gpu_unsupported_enable_triton_multi_output_fusion() const {
  bool value = (_impl_._has_bits_[6] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_enable_triton_multi_output_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_triton_multi_output_fusion_ = false;
  _impl_._has_bits_[6] &= ~0x00010000u;
}
inline bool DebugOptions::xla_gpu_unsupported_enable_triton_multi_output_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_triton_multi_output_fusion)
  return _internal_xla_gpu_unsupported_enable_triton_multi_output_fusion();
}
inline void DebugOptions::set_xla_gpu_unsupported_enable_triton_multi_output_fusion(bool value) {
  _internal_set_xla_gpu_unsupported_enable_triton_multi_output_fusion(value);
  _impl_._has_bits_[6] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_triton_multi_output_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_triton_multi_output_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_enable_triton_multi_output_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_triton_multi_output_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_enable_triton_multi_output_fusion_ = value;
}

// repeated .xla.DebugOptions.GenericTritonEmitterFeature xla_gpu_unsupported_generic_triton_emitter_features = 398;
inline int DebugOptions::_internal_xla_gpu_unsupported_generic_triton_emitter_features_size() const {
  return _internal_xla_gpu_unsupported_generic_triton_emitter_features().size();
}
inline int DebugOptions::xla_gpu_unsupported_generic_triton_emitter_features_size() const {
  return _internal_xla_gpu_unsupported_generic_triton_emitter_features_size();
}
inline void DebugOptions::clear_xla_gpu_unsupported_generic_triton_emitter_features() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_generic_triton_emitter_features_.Clear();
}
inline ::xla::DebugOptions_GenericTritonEmitterFeature DebugOptions::xla_gpu_unsupported_generic_triton_emitter_features(int index) const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_generic_triton_emitter_features)
  return static_cast<::xla::DebugOptions_GenericTritonEmitterFeature>(_internal_xla_gpu_unsupported_generic_triton_emitter_features().Get(index));
}
inline void DebugOptions::set_xla_gpu_unsupported_generic_triton_emitter_features(int index, ::xla::DebugOptions_GenericTritonEmitterFeature value) {
  _internal_mutable_xla_gpu_unsupported_generic_triton_emitter_features()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_generic_triton_emitter_features)
}
inline void DebugOptions::add_xla_gpu_unsupported_generic_triton_emitter_features(::xla::DebugOptions_GenericTritonEmitterFeature value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_xla_gpu_unsupported_generic_triton_emitter_features()->Add(value);
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_unsupported_generic_triton_emitter_features)
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::xla_gpu_unsupported_generic_triton_emitter_features() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_unsupported_generic_triton_emitter_features)
  return _internal_xla_gpu_unsupported_generic_triton_emitter_features();
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::mutable_xla_gpu_unsupported_generic_triton_emitter_features()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_unsupported_generic_triton_emitter_features)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_gpu_unsupported_generic_triton_emitter_features();
}
inline const ::google::protobuf::RepeatedField<int>& DebugOptions::_internal_xla_gpu_unsupported_generic_triton_emitter_features()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_generic_triton_emitter_features_;
}
inline ::google::protobuf::RepeatedField<int>* DebugOptions::_internal_mutable_xla_gpu_unsupported_generic_triton_emitter_features() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_gpu_unsupported_generic_triton_emitter_features_;
}

// optional bool xla_gpu_unsupported_use_all_reduce_one_shot_kernel = 387;
inline bool DebugOptions::has_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const {
  bool value = (_impl_._has_bits_[6] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_use_all_reduce_one_shot_kernel_ = false;
  _impl_._has_bits_[6] &= ~0x00020000u;
}
inline bool DebugOptions::xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_use_all_reduce_one_shot_kernel)
  return _internal_xla_gpu_unsupported_use_all_reduce_one_shot_kernel();
}
inline void DebugOptions::set_xla_gpu_unsupported_use_all_reduce_one_shot_kernel(bool value) {
  _internal_set_xla_gpu_unsupported_use_all_reduce_one_shot_kernel(value);
  _impl_._has_bits_[6] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_use_all_reduce_one_shot_kernel)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_use_all_reduce_one_shot_kernel() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_use_all_reduce_one_shot_kernel_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_use_all_reduce_one_shot_kernel(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_use_all_reduce_one_shot_kernel_ = value;
}

// optional bool xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel = 375;
inline bool DebugOptions::has_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const {
  bool value = (_impl_._has_bits_[6] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel_ = false;
  _impl_._has_bits_[6] &= ~0x00040000u;
}
inline bool DebugOptions::xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel)
  return _internal_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel();
}
inline void DebugOptions::set_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel(bool value) {
  _internal_set_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel(value);
  _impl_._has_bits_[6] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel)
}
inline bool DebugOptions::_internal_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel_;
}
inline void DebugOptions::_internal_set_xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_unsupported_use_ragged_all_to_all_one_shot_kernel_ = value;
}

// optional bool xla_gpu_use_inprocess_lld = 389;
inline bool DebugOptions::has_xla_gpu_use_inprocess_lld() const {
  bool value = (_impl_._has_bits_[6] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_use_inprocess_lld() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_inprocess_lld_ = false;
  _impl_._has_bits_[6] &= ~0x00080000u;
}
inline bool DebugOptions::xla_gpu_use_inprocess_lld() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_use_inprocess_lld)
  return _internal_xla_gpu_use_inprocess_lld();
}
inline void DebugOptions::set_xla_gpu_use_inprocess_lld(bool value) {
  _internal_set_xla_gpu_use_inprocess_lld(value);
  _impl_._has_bits_[6] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_use_inprocess_lld)
}
inline bool DebugOptions::_internal_xla_gpu_use_inprocess_lld() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_use_inprocess_lld_;
}
inline void DebugOptions::_internal_set_xla_gpu_use_inprocess_lld(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_inprocess_lld_ = value;
}

// optional bool xla_gpu_use_memcpy_local_p2p = 287;
inline bool DebugOptions::has_xla_gpu_use_memcpy_local_p2p() const {
  bool value = (_impl_._has_bits_[6] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_use_memcpy_local_p2p() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_memcpy_local_p2p_ = false;
  _impl_._has_bits_[6] &= ~0x00100000u;
}
inline bool DebugOptions::xla_gpu_use_memcpy_local_p2p() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_use_memcpy_local_p2p)
  return _internal_xla_gpu_use_memcpy_local_p2p();
}
inline void DebugOptions::set_xla_gpu_use_memcpy_local_p2p(bool value) {
  _internal_set_xla_gpu_use_memcpy_local_p2p(value);
  _impl_._has_bits_[6] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_use_memcpy_local_p2p)
}
inline bool DebugOptions::_internal_xla_gpu_use_memcpy_local_p2p() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_use_memcpy_local_p2p_;
}
inline void DebugOptions::_internal_set_xla_gpu_use_memcpy_local_p2p(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_memcpy_local_p2p_ = value;
}

// optional bool xla_gpu_use_runtime_fusion = 181;
inline bool DebugOptions::has_xla_gpu_use_runtime_fusion() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_use_runtime_fusion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_runtime_fusion_ = false;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline bool DebugOptions::xla_gpu_use_runtime_fusion() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_use_runtime_fusion)
  return _internal_xla_gpu_use_runtime_fusion();
}
inline void DebugOptions::set_xla_gpu_use_runtime_fusion(bool value) {
  _internal_set_xla_gpu_use_runtime_fusion(value);
  _impl_._has_bits_[1] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_use_runtime_fusion)
}
inline bool DebugOptions::_internal_xla_gpu_use_runtime_fusion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_use_runtime_fusion_;
}
inline void DebugOptions::_internal_set_xla_gpu_use_runtime_fusion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_use_runtime_fusion_ = value;
}

// optional bool xla_gpu_verify_triton_fusion_numerics = 291;
inline bool DebugOptions::has_xla_gpu_verify_triton_fusion_numerics() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_verify_triton_fusion_numerics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_verify_triton_fusion_numerics_ = false;
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline bool DebugOptions::xla_gpu_verify_triton_fusion_numerics() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_verify_triton_fusion_numerics)
  return _internal_xla_gpu_verify_triton_fusion_numerics();
}
inline void DebugOptions::set_xla_gpu_verify_triton_fusion_numerics(bool value) {
  _internal_set_xla_gpu_verify_triton_fusion_numerics(value);
  _impl_._has_bits_[1] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_verify_triton_fusion_numerics)
}
inline bool DebugOptions::_internal_xla_gpu_verify_triton_fusion_numerics() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_verify_triton_fusion_numerics_;
}
inline void DebugOptions::_internal_set_xla_gpu_verify_triton_fusion_numerics(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_verify_triton_fusion_numerics_ = value;
}

// optional bool xla_hlo_graph_addresses = 2;
inline bool DebugOptions::has_xla_hlo_graph_addresses() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_hlo_graph_addresses() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_graph_addresses_ = false;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline bool DebugOptions::xla_hlo_graph_addresses() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_graph_addresses)
  return _internal_xla_hlo_graph_addresses();
}
inline void DebugOptions::set_xla_hlo_graph_addresses(bool value) {
  _internal_set_xla_hlo_graph_addresses(value);
  _impl_._has_bits_[1] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_graph_addresses)
}
inline bool DebugOptions::_internal_xla_hlo_graph_addresses() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_hlo_graph_addresses_;
}
inline void DebugOptions::_internal_set_xla_hlo_graph_addresses(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_graph_addresses_ = value;
}

// optional bool xla_hlo_profile = 9;
inline bool DebugOptions::has_xla_hlo_profile() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_hlo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_profile_ = false;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline bool DebugOptions::xla_hlo_profile() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_profile)
  return _internal_xla_hlo_profile();
}
inline void DebugOptions::set_xla_hlo_profile(bool value) {
  _internal_set_xla_hlo_profile(value);
  _impl_._has_bits_[1] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_profile)
}
inline bool DebugOptions::_internal_xla_hlo_profile() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_hlo_profile_;
}
inline void DebugOptions::_internal_set_xla_hlo_profile(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_profile_ = value;
}

// repeated string xla_disable_hlo_passes = 30;
inline int DebugOptions::_internal_xla_disable_hlo_passes_size() const {
  return _internal_xla_disable_hlo_passes().size();
}
inline int DebugOptions::xla_disable_hlo_passes_size() const {
  return _internal_xla_disable_hlo_passes_size();
}
inline void DebugOptions::clear_xla_disable_hlo_passes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_disable_hlo_passes_.Clear();
}
inline std::string* DebugOptions::add_xla_disable_hlo_passes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_xla_disable_hlo_passes()->Add();
  // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_disable_hlo_passes)
  return _s;
}
inline const std::string& DebugOptions::xla_disable_hlo_passes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_disable_hlo_passes)
  return _internal_xla_disable_hlo_passes().Get(index);
}
inline std::string* DebugOptions::mutable_xla_disable_hlo_passes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_disable_hlo_passes)
  return _internal_mutable_xla_disable_hlo_passes()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::set_xla_disable_hlo_passes(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_xla_disable_hlo_passes()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_disable_hlo_passes)
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::add_xla_disable_hlo_passes(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_xla_disable_hlo_passes(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_disable_hlo_passes)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::xla_disable_hlo_passes() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_disable_hlo_passes)
  return _internal_xla_disable_hlo_passes();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::mutable_xla_disable_hlo_passes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_disable_hlo_passes)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_disable_hlo_passes();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::_internal_xla_disable_hlo_passes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_disable_hlo_passes_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::_internal_mutable_xla_disable_hlo_passes() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_disable_hlo_passes_;
}

// repeated string xla_enable_hlo_passes_only = 124;
inline int DebugOptions::_internal_xla_enable_hlo_passes_only_size() const {
  return _internal_xla_enable_hlo_passes_only().size();
}
inline int DebugOptions::xla_enable_hlo_passes_only_size() const {
  return _internal_xla_enable_hlo_passes_only_size();
}
inline void DebugOptions::clear_xla_enable_hlo_passes_only() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_hlo_passes_only_.Clear();
}
inline std::string* DebugOptions::add_xla_enable_hlo_passes_only() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_xla_enable_hlo_passes_only()->Add();
  // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_enable_hlo_passes_only)
  return _s;
}
inline const std::string& DebugOptions::xla_enable_hlo_passes_only(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_hlo_passes_only)
  return _internal_xla_enable_hlo_passes_only().Get(index);
}
inline std::string* DebugOptions::mutable_xla_enable_hlo_passes_only(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_enable_hlo_passes_only)
  return _internal_mutable_xla_enable_hlo_passes_only()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::set_xla_enable_hlo_passes_only(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_xla_enable_hlo_passes_only()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_hlo_passes_only)
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::add_xla_enable_hlo_passes_only(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_xla_enable_hlo_passes_only(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_enable_hlo_passes_only)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::xla_enable_hlo_passes_only() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_enable_hlo_passes_only)
  return _internal_xla_enable_hlo_passes_only();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::mutable_xla_enable_hlo_passes_only() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_enable_hlo_passes_only)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_xla_enable_hlo_passes_only();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::_internal_xla_enable_hlo_passes_only() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_enable_hlo_passes_only_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::_internal_mutable_xla_enable_hlo_passes_only() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.xla_enable_hlo_passes_only_;
}

// optional bool xla_disable_all_hlo_passes = 104;
inline bool DebugOptions::has_xla_disable_all_hlo_passes() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_disable_all_hlo_passes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_disable_all_hlo_passes_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool DebugOptions::xla_disable_all_hlo_passes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_disable_all_hlo_passes)
  return _internal_xla_disable_all_hlo_passes();
}
inline void DebugOptions::set_xla_disable_all_hlo_passes(bool value) {
  _internal_set_xla_disable_all_hlo_passes(value);
  _impl_._has_bits_[0] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_disable_all_hlo_passes)
}
inline bool DebugOptions::_internal_xla_disable_all_hlo_passes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_disable_all_hlo_passes_;
}
inline void DebugOptions::_internal_set_xla_disable_all_hlo_passes(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_disable_all_hlo_passes_ = value;
}

// optional int32 xla_backend_optimization_level = 31;
inline bool DebugOptions::has_xla_backend_optimization_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_backend_optimization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_backend_optimization_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::int32_t DebugOptions::xla_backend_optimization_level() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_backend_optimization_level)
  return _internal_xla_backend_optimization_level();
}
inline void DebugOptions::set_xla_backend_optimization_level(::int32_t value) {
  _internal_set_xla_backend_optimization_level(value);
  _impl_._has_bits_[0] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_backend_optimization_level)
}
inline ::int32_t DebugOptions::_internal_xla_backend_optimization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_backend_optimization_level_;
}
inline void DebugOptions::_internal_set_xla_backend_optimization_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_backend_optimization_level_ = value;
}

// optional bool xla_embed_ir_in_executable = 33;
inline bool DebugOptions::has_xla_embed_ir_in_executable() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_embed_ir_in_executable() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_embed_ir_in_executable_ = false;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline bool DebugOptions::xla_embed_ir_in_executable() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_embed_ir_in_executable)
  return _internal_xla_embed_ir_in_executable();
}
inline void DebugOptions::set_xla_embed_ir_in_executable(bool value) {
  _internal_set_xla_embed_ir_in_executable(value);
  _impl_._has_bits_[0] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_embed_ir_in_executable)
}
inline bool DebugOptions::_internal_xla_embed_ir_in_executable() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_embed_ir_in_executable_;
}
inline void DebugOptions::_internal_set_xla_embed_ir_in_executable(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_embed_ir_in_executable_ = value;
}

// optional bool xla_eliminate_hlo_implicit_broadcast = 35;
inline bool DebugOptions::has_xla_eliminate_hlo_implicit_broadcast() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_eliminate_hlo_implicit_broadcast() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_eliminate_hlo_implicit_broadcast_ = false;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline bool DebugOptions::xla_eliminate_hlo_implicit_broadcast() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_eliminate_hlo_implicit_broadcast)
  return _internal_xla_eliminate_hlo_implicit_broadcast();
}
inline void DebugOptions::set_xla_eliminate_hlo_implicit_broadcast(bool value) {
  _internal_set_xla_eliminate_hlo_implicit_broadcast(value);
  _impl_._has_bits_[0] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_eliminate_hlo_implicit_broadcast)
}
inline bool DebugOptions::_internal_xla_eliminate_hlo_implicit_broadcast() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_eliminate_hlo_implicit_broadcast_;
}
inline void DebugOptions::_internal_set_xla_eliminate_hlo_implicit_broadcast(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_eliminate_hlo_implicit_broadcast_ = value;
}

// optional bool xla_cpu_multi_thread_eigen = 60;
inline bool DebugOptions::has_xla_cpu_multi_thread_eigen() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_multi_thread_eigen() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_multi_thread_eigen_ = false;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool DebugOptions::xla_cpu_multi_thread_eigen() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_multi_thread_eigen)
  return _internal_xla_cpu_multi_thread_eigen();
}
inline void DebugOptions::set_xla_cpu_multi_thread_eigen(bool value) {
  _internal_set_xla_cpu_multi_thread_eigen(value);
  _impl_._has_bits_[0] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_multi_thread_eigen)
}
inline bool DebugOptions::_internal_xla_cpu_multi_thread_eigen() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_multi_thread_eigen_;
}
inline void DebugOptions::_internal_set_xla_cpu_multi_thread_eigen(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_multi_thread_eigen_ = value;
}

// optional bool xla_llvm_enable_alias_scope_metadata = 70;
inline bool DebugOptions::has_xla_llvm_enable_alias_scope_metadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_llvm_enable_alias_scope_metadata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_alias_scope_metadata_ = false;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool DebugOptions::xla_llvm_enable_alias_scope_metadata() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_alias_scope_metadata)
  return _internal_xla_llvm_enable_alias_scope_metadata();
}
inline void DebugOptions::set_xla_llvm_enable_alias_scope_metadata(bool value) {
  _internal_set_xla_llvm_enable_alias_scope_metadata(value);
  _impl_._has_bits_[0] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_alias_scope_metadata)
}
inline bool DebugOptions::_internal_xla_llvm_enable_alias_scope_metadata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_llvm_enable_alias_scope_metadata_;
}
inline void DebugOptions::_internal_set_xla_llvm_enable_alias_scope_metadata(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_alias_scope_metadata_ = value;
}

// optional bool xla_llvm_enable_noalias_metadata = 71;
inline bool DebugOptions::has_xla_llvm_enable_noalias_metadata() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_llvm_enable_noalias_metadata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_noalias_metadata_ = false;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline bool DebugOptions::xla_llvm_enable_noalias_metadata() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_noalias_metadata)
  return _internal_xla_llvm_enable_noalias_metadata();
}
inline void DebugOptions::set_xla_llvm_enable_noalias_metadata(bool value) {
  _internal_set_xla_llvm_enable_noalias_metadata(value);
  _impl_._has_bits_[0] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_noalias_metadata)
}
inline bool DebugOptions::_internal_xla_llvm_enable_noalias_metadata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_llvm_enable_noalias_metadata_;
}
inline void DebugOptions::_internal_set_xla_llvm_enable_noalias_metadata(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_noalias_metadata_ = value;
}

// optional bool xla_llvm_enable_invariant_load_metadata = 72;
inline bool DebugOptions::has_xla_llvm_enable_invariant_load_metadata() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_llvm_enable_invariant_load_metadata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_invariant_load_metadata_ = false;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline bool DebugOptions::xla_llvm_enable_invariant_load_metadata() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_invariant_load_metadata)
  return _internal_xla_llvm_enable_invariant_load_metadata();
}
inline void DebugOptions::set_xla_llvm_enable_invariant_load_metadata(bool value) {
  _internal_set_xla_llvm_enable_invariant_load_metadata(value);
  _impl_._has_bits_[0] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_invariant_load_metadata)
}
inline bool DebugOptions::_internal_xla_llvm_enable_invariant_load_metadata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_llvm_enable_invariant_load_metadata_;
}
inline void DebugOptions::_internal_set_xla_llvm_enable_invariant_load_metadata(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_enable_invariant_load_metadata_ = value;
}

// optional bool xla_llvm_disable_expensive_passes = 73;
inline bool DebugOptions::has_xla_llvm_disable_expensive_passes() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_llvm_disable_expensive_passes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_disable_expensive_passes_ = false;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline bool DebugOptions::xla_llvm_disable_expensive_passes() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_disable_expensive_passes)
  return _internal_xla_llvm_disable_expensive_passes();
}
inline void DebugOptions::set_xla_llvm_disable_expensive_passes(bool value) {
  _internal_set_xla_llvm_disable_expensive_passes(value);
  _impl_._has_bits_[0] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_disable_expensive_passes)
}
inline bool DebugOptions::_internal_xla_llvm_disable_expensive_passes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_llvm_disable_expensive_passes_;
}
inline void DebugOptions::_internal_set_xla_llvm_disable_expensive_passes(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_disable_expensive_passes_ = value;
}

// optional bool xla_test_all_output_layouts = 90;
inline bool DebugOptions::has_xla_test_all_output_layouts() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_test_all_output_layouts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_all_output_layouts_ = false;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline bool DebugOptions::xla_test_all_output_layouts() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_test_all_output_layouts)
  return _internal_xla_test_all_output_layouts();
}
inline void DebugOptions::set_xla_test_all_output_layouts(bool value) {
  _internal_set_xla_test_all_output_layouts(value);
  _impl_._has_bits_[0] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_test_all_output_layouts)
}
inline bool DebugOptions::_internal_xla_test_all_output_layouts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_test_all_output_layouts_;
}
inline void DebugOptions::_internal_set_xla_test_all_output_layouts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_all_output_layouts_ = value;
}

// optional bool xla_test_all_input_layouts = 91;
inline bool DebugOptions::has_xla_test_all_input_layouts() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_test_all_input_layouts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_all_input_layouts_ = false;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline bool DebugOptions::xla_test_all_input_layouts() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_test_all_input_layouts)
  return _internal_xla_test_all_input_layouts();
}
inline void DebugOptions::set_xla_test_all_input_layouts(bool value) {
  _internal_set_xla_test_all_input_layouts(value);
  _impl_._has_bits_[0] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_test_all_input_layouts)
}
inline bool DebugOptions::_internal_xla_test_all_input_layouts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_test_all_input_layouts_;
}
inline void DebugOptions::_internal_set_xla_test_all_input_layouts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_all_input_layouts_ = value;
}

// optional bool xla_hlo_graph_sharding_color = 92;
inline bool DebugOptions::has_xla_hlo_graph_sharding_color() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_hlo_graph_sharding_color() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_graph_sharding_color_ = false;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline bool DebugOptions::xla_hlo_graph_sharding_color() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_graph_sharding_color)
  return _internal_xla_hlo_graph_sharding_color();
}
inline void DebugOptions::set_xla_hlo_graph_sharding_color(bool value) {
  _internal_set_xla_hlo_graph_sharding_color(value);
  _impl_._has_bits_[0] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_graph_sharding_color)
}
inline bool DebugOptions::_internal_xla_hlo_graph_sharding_color() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_hlo_graph_sharding_color_;
}
inline void DebugOptions::_internal_set_xla_hlo_graph_sharding_color(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_graph_sharding_color_ = value;
}

// optional bool xla_cpu_use_onednn = 97;
inline bool DebugOptions::has_xla_cpu_use_onednn() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_use_onednn() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_onednn_ = false;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline bool DebugOptions::xla_cpu_use_onednn() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_onednn)
  return _internal_xla_cpu_use_onednn();
}
inline void DebugOptions::set_xla_cpu_use_onednn(bool value) {
  _internal_set_xla_cpu_use_onednn(value);
  _impl_._has_bits_[0] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_onednn)
}
inline bool DebugOptions::_internal_xla_cpu_use_onednn() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_use_onednn_;
}
inline void DebugOptions::_internal_set_xla_cpu_use_onednn(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_onednn_ = value;
}

// optional bool xla_allow_excess_precision = 122;
inline bool DebugOptions::has_xla_allow_excess_precision() const {
  bool value = (_impl_._has_bits_[2] & 0x00000040u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_allow_excess_precision() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_allow_excess_precision_ = false;
  _impl_._has_bits_[2] &= ~0x00000040u;
}
inline bool DebugOptions::xla_allow_excess_precision() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_allow_excess_precision)
  return _internal_xla_allow_excess_precision();
}
inline void DebugOptions::set_xla_allow_excess_precision(bool value) {
  _internal_set_xla_allow_excess_precision(value);
  _impl_._has_bits_[2] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_allow_excess_precision)
}
inline bool DebugOptions::_internal_xla_allow_excess_precision() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_allow_excess_precision_;
}
inline void DebugOptions::_internal_set_xla_allow_excess_precision(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_allow_excess_precision_ = value;
}

// optional int32 xla_force_host_platform_device_count = 102;
inline bool DebugOptions::has_xla_force_host_platform_device_count() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_force_host_platform_device_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_force_host_platform_device_count_ = 0;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline ::int32_t DebugOptions::xla_force_host_platform_device_count() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_force_host_platform_device_count)
  return _internal_xla_force_host_platform_device_count();
}
inline void DebugOptions::set_xla_force_host_platform_device_count(::int32_t value) {
  _internal_set_xla_force_host_platform_device_count(value);
  _impl_._has_bits_[0] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_force_host_platform_device_count)
}
inline ::int32_t DebugOptions::_internal_xla_force_host_platform_device_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_force_host_platform_device_count_;
}
inline void DebugOptions::_internal_set_xla_force_host_platform_device_count(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_force_host_platform_device_count_ = value;
}

// optional bool xla_hlo_evaluator_use_fast_path = 106;
inline bool DebugOptions::has_xla_hlo_evaluator_use_fast_path() const {
  bool value = (_impl_._has_bits_[2] & 0x00000080u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_hlo_evaluator_use_fast_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_evaluator_use_fast_path_ = false;
  _impl_._has_bits_[2] &= ~0x00000080u;
}
inline bool DebugOptions::xla_hlo_evaluator_use_fast_path() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_evaluator_use_fast_path)
  return _internal_xla_hlo_evaluator_use_fast_path();
}
inline void DebugOptions::set_xla_hlo_evaluator_use_fast_path(bool value) {
  _internal_set_xla_hlo_evaluator_use_fast_path(value);
  _impl_._has_bits_[2] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_evaluator_use_fast_path)
}
inline bool DebugOptions::_internal_xla_hlo_evaluator_use_fast_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_hlo_evaluator_use_fast_path_;
}
inline void DebugOptions::_internal_set_xla_hlo_evaluator_use_fast_path(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_hlo_evaluator_use_fast_path_ = value;
}

// optional bool xla_allow_scalar_index_dynamic_ops = 107;
inline bool DebugOptions::has_xla_allow_scalar_index_dynamic_ops() const {
  bool value = (_impl_._has_bits_[2] & 0x00000100u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_allow_scalar_index_dynamic_ops() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_allow_scalar_index_dynamic_ops_ = false;
  _impl_._has_bits_[2] &= ~0x00000100u;
}
inline bool DebugOptions::xla_allow_scalar_index_dynamic_ops() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_allow_scalar_index_dynamic_ops)
  return _internal_xla_allow_scalar_index_dynamic_ops();
}
inline void DebugOptions::set_xla_allow_scalar_index_dynamic_ops(bool value) {
  _internal_set_xla_allow_scalar_index_dynamic_ops(value);
  _impl_._has_bits_[2] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_allow_scalar_index_dynamic_ops)
}
inline bool DebugOptions::_internal_xla_allow_scalar_index_dynamic_ops() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_allow_scalar_index_dynamic_ops_;
}
inline void DebugOptions::_internal_set_xla_allow_scalar_index_dynamic_ops(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_allow_scalar_index_dynamic_ops_ = value;
}

// optional .xla.DebugOptions.StepMarkerLocation xla_step_marker_location = 108;
inline bool DebugOptions::has_xla_step_marker_location() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_step_marker_location() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_step_marker_location_ = 0;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline ::xla::DebugOptions_StepMarkerLocation DebugOptions::xla_step_marker_location() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_step_marker_location)
  return _internal_xla_step_marker_location();
}
inline void DebugOptions::set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value) {
  _internal_set_xla_step_marker_location(value);
  _impl_._has_bits_[1] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_step_marker_location)
}
inline ::xla::DebugOptions_StepMarkerLocation DebugOptions::_internal_xla_step_marker_location() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_StepMarkerLocation>(_impl_.xla_step_marker_location_);
}
inline void DebugOptions::_internal_set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_step_marker_location_ = value;
}

// optional string xla_dump_to = 109;
inline bool DebugOptions::has_xla_dump_to() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_to_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DebugOptions::xla_dump_to() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_to)
  return _internal_xla_dump_to();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_to(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.xla_dump_to_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_to)
}
inline std::string* DebugOptions::mutable_xla_dump_to() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_dump_to();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_to)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_dump_to() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_to_.Get();
}
inline void DebugOptions::_internal_set_xla_dump_to(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.xla_dump_to_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_dump_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.xla_dump_to_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_dump_to() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_to)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* released = _impl_.xla_dump_to_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_dump_to_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_dump_to(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.xla_dump_to_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_dump_to_.IsDefault()) {
          _impl_.xla_dump_to_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_to)
}

// optional bool xla_flags_reset = 364;
inline bool DebugOptions::has_xla_flags_reset() const {
  bool value = (_impl_._has_bits_[2] & 0x00000200u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_flags_reset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_flags_reset_ = false;
  _impl_._has_bits_[2] &= ~0x00000200u;
}
inline bool DebugOptions::xla_flags_reset() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_flags_reset)
  return _internal_xla_flags_reset();
}
inline void DebugOptions::set_xla_flags_reset(bool value) {
  _internal_set_xla_flags_reset(value);
  _impl_._has_bits_[2] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_flags_reset)
}
inline bool DebugOptions::_internal_xla_flags_reset() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_flags_reset_;
}
inline void DebugOptions::_internal_set_xla_flags_reset(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_flags_reset_ = value;
}

// optional string xla_dump_hlo_module_re = 110;
inline bool DebugOptions::has_xla_dump_hlo_module_re() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_module_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_module_re_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DebugOptions::xla_dump_hlo_module_re() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_module_re)
  return _internal_xla_dump_hlo_module_re();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_module_re(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.xla_dump_hlo_module_re_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_module_re)
}
inline std::string* DebugOptions::mutable_xla_dump_hlo_module_re() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_dump_hlo_module_re();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_module_re)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_dump_hlo_module_re() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_module_re_.Get();
}
inline void DebugOptions::_internal_set_xla_dump_hlo_module_re(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.xla_dump_hlo_module_re_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_module_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.xla_dump_hlo_module_re_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_dump_hlo_module_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_module_re)
  if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* released = _impl_.xla_dump_hlo_module_re_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_dump_hlo_module_re_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_dump_hlo_module_re(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.xla_dump_hlo_module_re_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_dump_hlo_module_re_.IsDefault()) {
          _impl_.xla_dump_hlo_module_re_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_module_re)
}

// optional string xla_dump_hlo_pass_re = 111;
inline bool DebugOptions::has_xla_dump_hlo_pass_re() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_pass_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_pass_re_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& DebugOptions::xla_dump_hlo_pass_re() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_pass_re)
  return _internal_xla_dump_hlo_pass_re();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_pass_re(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.xla_dump_hlo_pass_re_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_pass_re)
}
inline std::string* DebugOptions::mutable_xla_dump_hlo_pass_re() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_dump_hlo_pass_re();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_pass_re)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_dump_hlo_pass_re() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_pass_re_.Get();
}
inline void DebugOptions::_internal_set_xla_dump_hlo_pass_re(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.xla_dump_hlo_pass_re_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_pass_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.xla_dump_hlo_pass_re_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_dump_hlo_pass_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_pass_re)
  if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* released = _impl_.xla_dump_hlo_pass_re_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_dump_hlo_pass_re_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_dump_hlo_pass_re(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.xla_dump_hlo_pass_re_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_dump_hlo_pass_re_.IsDefault()) {
          _impl_.xla_dump_hlo_pass_re_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_pass_re)
}

// optional bool xla_dump_hlo_as_text = 112;
inline bool DebugOptions::has_xla_dump_hlo_as_text() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_text_ = false;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline bool DebugOptions::xla_dump_hlo_as_text() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_text)
  return _internal_xla_dump_hlo_as_text();
}
inline void DebugOptions::set_xla_dump_hlo_as_text(bool value) {
  _internal_set_xla_dump_hlo_as_text(value);
  _impl_._has_bits_[1] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_text)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_text() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_text_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_text(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_text_ = value;
}

// optional bool xla_dump_hlo_as_proto = 113;
inline bool DebugOptions::has_xla_dump_hlo_as_proto() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_proto() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_proto_ = false;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline bool DebugOptions::xla_dump_hlo_as_proto() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_proto)
  return _internal_xla_dump_hlo_as_proto();
}
inline void DebugOptions::set_xla_dump_hlo_as_proto(bool value) {
  _internal_set_xla_dump_hlo_as_proto(value);
  _impl_._has_bits_[1] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_proto)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_proto() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_proto_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_proto(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_proto_ = value;
}

// optional bool xla_dump_hlo_as_dot = 114;
inline bool DebugOptions::has_xla_dump_hlo_as_dot() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_dot() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_dot_ = false;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline bool DebugOptions::xla_dump_hlo_as_dot() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_dot)
  return _internal_xla_dump_hlo_as_dot();
}
inline void DebugOptions::set_xla_dump_hlo_as_dot(bool value) {
  _internal_set_xla_dump_hlo_as_dot(value);
  _impl_._has_bits_[1] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_dot)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_dot() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_dot_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_dot(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_dot_ = value;
}

// optional bool xla_dump_hlo_as_url = 115;
inline bool DebugOptions::has_xla_dump_hlo_as_url() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_url() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_url_ = false;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline bool DebugOptions::xla_dump_hlo_as_url() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_url)
  return _internal_xla_dump_hlo_as_url();
}
inline void DebugOptions::set_xla_dump_hlo_as_url(bool value) {
  _internal_set_xla_dump_hlo_as_url(value);
  _impl_._has_bits_[1] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_url)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_url() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_url_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_url(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_url_ = value;
}

// optional bool xla_dump_hlo_as_html = 116;
inline bool DebugOptions::has_xla_dump_hlo_as_html() const {
  bool value = (_impl_._has_bits_[1] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_html() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_html_ = false;
  _impl_._has_bits_[1] &= ~0x00004000u;
}
inline bool DebugOptions::xla_dump_hlo_as_html() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_html)
  return _internal_xla_dump_hlo_as_html();
}
inline void DebugOptions::set_xla_dump_hlo_as_html(bool value) {
  _internal_set_xla_dump_hlo_as_html(value);
  _impl_._has_bits_[1] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_html)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_html() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_html_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_html(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_html_ = value;
}

// optional bool xla_dump_fusion_visualization = 149;
inline bool DebugOptions::has_xla_dump_fusion_visualization() const {
  bool value = (_impl_._has_bits_[1] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_fusion_visualization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_fusion_visualization_ = false;
  _impl_._has_bits_[1] &= ~0x00008000u;
}
inline bool DebugOptions::xla_dump_fusion_visualization() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_fusion_visualization)
  return _internal_xla_dump_fusion_visualization();
}
inline void DebugOptions::set_xla_dump_fusion_visualization(bool value) {
  _internal_set_xla_dump_fusion_visualization(value);
  _impl_._has_bits_[1] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_fusion_visualization)
}
inline bool DebugOptions::_internal_xla_dump_fusion_visualization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_fusion_visualization_;
}
inline void DebugOptions::_internal_set_xla_dump_fusion_visualization(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_fusion_visualization_ = value;
}

// optional bool xla_dump_hlo_snapshots = 118;
inline bool DebugOptions::has_xla_dump_hlo_snapshots() const {
  bool value = (_impl_._has_bits_[1] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_snapshots() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_snapshots_ = false;
  _impl_._has_bits_[1] &= ~0x00010000u;
}
inline bool DebugOptions::xla_dump_hlo_snapshots() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_snapshots)
  return _internal_xla_dump_hlo_snapshots();
}
inline void DebugOptions::set_xla_dump_hlo_snapshots(bool value) {
  _internal_set_xla_dump_hlo_snapshots(value);
  _impl_._has_bits_[1] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_snapshots)
}
inline bool DebugOptions::_internal_xla_dump_hlo_snapshots() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_snapshots_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_snapshots(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_snapshots_ = value;
}

// optional bool xla_dump_include_timestamp = 131;
inline bool DebugOptions::has_xla_dump_include_timestamp() const {
  bool value = (_impl_._has_bits_[1] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_include_timestamp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_include_timestamp_ = false;
  _impl_._has_bits_[1] &= ~0x00020000u;
}
inline bool DebugOptions::xla_dump_include_timestamp() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_include_timestamp)
  return _internal_xla_dump_include_timestamp();
}
inline void DebugOptions::set_xla_dump_include_timestamp(bool value) {
  _internal_set_xla_dump_include_timestamp(value);
  _impl_._has_bits_[1] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_include_timestamp)
}
inline bool DebugOptions::_internal_xla_dump_include_timestamp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_include_timestamp_;
}
inline void DebugOptions::_internal_set_xla_dump_include_timestamp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_include_timestamp_ = value;
}

// optional int32 xla_dump_max_hlo_modules = 132;
inline bool DebugOptions::has_xla_dump_max_hlo_modules() const {
  bool value = (_impl_._has_bits_[1] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_max_hlo_modules() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_max_hlo_modules_ = 0;
  _impl_._has_bits_[1] &= ~0x00040000u;
}
inline ::int32_t DebugOptions::xla_dump_max_hlo_modules() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_max_hlo_modules)
  return _internal_xla_dump_max_hlo_modules();
}
inline void DebugOptions::set_xla_dump_max_hlo_modules(::int32_t value) {
  _internal_set_xla_dump_max_hlo_modules(value);
  _impl_._has_bits_[1] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_max_hlo_modules)
}
inline ::int32_t DebugOptions::_internal_xla_dump_max_hlo_modules() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_max_hlo_modules_;
}
inline void DebugOptions::_internal_set_xla_dump_max_hlo_modules(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_max_hlo_modules_ = value;
}

// optional bool xla_dump_module_metadata = 144;
inline bool DebugOptions::has_xla_dump_module_metadata() const {
  bool value = (_impl_._has_bits_[1] & 0x08000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_module_metadata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_module_metadata_ = false;
  _impl_._has_bits_[1] &= ~0x08000000u;
}
inline bool DebugOptions::xla_dump_module_metadata() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_module_metadata)
  return _internal_xla_dump_module_metadata();
}
inline void DebugOptions::set_xla_dump_module_metadata(bool value) {
  _internal_set_xla_dump_module_metadata(value);
  _impl_._has_bits_[1] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_module_metadata)
}
inline bool DebugOptions::_internal_xla_dump_module_metadata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_module_metadata_;
}
inline void DebugOptions::_internal_set_xla_dump_module_metadata(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_module_metadata_ = value;
}

// optional bool xla_dump_compress_protos = 151;
inline bool DebugOptions::has_xla_dump_compress_protos() const {
  bool value = (_impl_._has_bits_[1] & 0x10000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_compress_protos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_compress_protos_ = false;
  _impl_._has_bits_[1] &= ~0x10000000u;
}
inline bool DebugOptions::xla_dump_compress_protos() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_compress_protos)
  return _internal_xla_dump_compress_protos();
}
inline void DebugOptions::set_xla_dump_compress_protos(bool value) {
  _internal_set_xla_dump_compress_protos(value);
  _impl_._has_bits_[1] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_compress_protos)
}
inline bool DebugOptions::_internal_xla_dump_compress_protos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_compress_protos_;
}
inline void DebugOptions::_internal_set_xla_dump_compress_protos(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_compress_protos_ = value;
}

// optional bool xla_dump_hlo_as_long_text = 164;
inline bool DebugOptions::has_xla_dump_hlo_as_long_text() const {
  bool value = (_impl_._has_bits_[1] & 0x20000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_as_long_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_long_text_ = false;
  _impl_._has_bits_[1] &= ~0x20000000u;
}
inline bool DebugOptions::xla_dump_hlo_as_long_text() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_long_text)
  return _internal_xla_dump_hlo_as_long_text();
}
inline void DebugOptions::set_xla_dump_hlo_as_long_text(bool value) {
  _internal_set_xla_dump_hlo_as_long_text(value);
  _impl_._has_bits_[1] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_long_text)
}
inline bool DebugOptions::_internal_xla_dump_hlo_as_long_text() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_as_long_text_;
}
inline void DebugOptions::_internal_set_xla_dump_hlo_as_long_text(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_as_long_text_ = value;
}

// optional bool xla_dump_enable_mlir_pretty_form = 185;
inline bool DebugOptions::has_xla_dump_enable_mlir_pretty_form() const {
  bool value = (_impl_._has_bits_[1] & 0x40000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_enable_mlir_pretty_form() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_enable_mlir_pretty_form_ = false;
  _impl_._has_bits_[1] &= ~0x40000000u;
}
inline bool DebugOptions::xla_dump_enable_mlir_pretty_form() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_enable_mlir_pretty_form)
  return _internal_xla_dump_enable_mlir_pretty_form();
}
inline void DebugOptions::set_xla_dump_enable_mlir_pretty_form(bool value) {
  _internal_set_xla_dump_enable_mlir_pretty_form(value);
  _impl_._has_bits_[1] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_enable_mlir_pretty_form)
}
inline bool DebugOptions::_internal_xla_dump_enable_mlir_pretty_form() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_enable_mlir_pretty_form_;
}
inline void DebugOptions::_internal_set_xla_dump_enable_mlir_pretty_form(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_enable_mlir_pretty_form_ = value;
}

// optional bool xla_dump_full_hlo_config = 381;
inline bool DebugOptions::has_xla_dump_full_hlo_config() const {
  bool value = (_impl_._has_bits_[2] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_full_hlo_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_full_hlo_config_ = false;
  _impl_._has_bits_[2] &= ~0x00008000u;
}
inline bool DebugOptions::xla_dump_full_hlo_config() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_full_hlo_config)
  return _internal_xla_dump_full_hlo_config();
}
inline void DebugOptions::set_xla_dump_full_hlo_config(bool value) {
  _internal_set_xla_dump_full_hlo_config(value);
  _impl_._has_bits_[2] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_full_hlo_config)
}
inline bool DebugOptions::_internal_xla_dump_full_hlo_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_full_hlo_config_;
}
inline void DebugOptions::_internal_set_xla_dump_full_hlo_config(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_full_hlo_config_ = value;
}

// optional bool xla_tpu_detect_nan = 135;
inline bool DebugOptions::has_xla_tpu_detect_nan() const {
  bool value = (_impl_._has_bits_[2] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_tpu_detect_nan() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_tpu_detect_nan_ = false;
  _impl_._has_bits_[2] &= ~0x00010000u;
}
inline bool DebugOptions::xla_tpu_detect_nan() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_tpu_detect_nan)
  return _internal_xla_tpu_detect_nan();
}
inline void DebugOptions::set_xla_tpu_detect_nan(bool value) {
  _internal_set_xla_tpu_detect_nan(value);
  _impl_._has_bits_[2] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_tpu_detect_nan)
}
inline bool DebugOptions::_internal_xla_tpu_detect_nan() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_tpu_detect_nan_;
}
inline void DebugOptions::_internal_set_xla_tpu_detect_nan(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_tpu_detect_nan_ = value;
}

// optional bool xla_tpu_detect_inf = 136;
inline bool DebugOptions::has_xla_tpu_detect_inf() const {
  bool value = (_impl_._has_bits_[2] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_tpu_detect_inf() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_tpu_detect_inf_ = false;
  _impl_._has_bits_[2] &= ~0x00020000u;
}
inline bool DebugOptions::xla_tpu_detect_inf() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_tpu_detect_inf)
  return _internal_xla_tpu_detect_inf();
}
inline void DebugOptions::set_xla_tpu_detect_inf(bool value) {
  _internal_set_xla_tpu_detect_inf(value);
  _impl_._has_bits_[2] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_tpu_detect_inf)
}
inline bool DebugOptions::_internal_xla_tpu_detect_inf() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_tpu_detect_inf_;
}
inline void DebugOptions::_internal_set_xla_tpu_detect_inf(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_tpu_detect_inf_ = value;
}

// optional bool xla_cpu_enable_xprof_traceme = 137;
inline bool DebugOptions::has_xla_cpu_enable_xprof_traceme() const {
  bool value = (_impl_._has_bits_[2] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_enable_xprof_traceme() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_xprof_traceme_ = false;
  _impl_._has_bits_[2] &= ~0x00040000u;
}
inline bool DebugOptions::xla_cpu_enable_xprof_traceme() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_xprof_traceme)
  return _internal_xla_cpu_enable_xprof_traceme();
}
inline void DebugOptions::set_xla_cpu_enable_xprof_traceme(bool value) {
  _internal_set_xla_cpu_enable_xprof_traceme(value);
  _impl_._has_bits_[2] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_xprof_traceme)
}
inline bool DebugOptions::_internal_xla_cpu_enable_xprof_traceme() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_enable_xprof_traceme_;
}
inline void DebugOptions::_internal_set_xla_cpu_enable_xprof_traceme(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_enable_xprof_traceme_ = value;
}

// optional int32 xla_multiheap_size_constraint_per_heap = 142;
inline bool DebugOptions::has_xla_multiheap_size_constraint_per_heap() const {
  bool value = (_impl_._has_bits_[1] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_multiheap_size_constraint_per_heap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_multiheap_size_constraint_per_heap_ = 0;
  _impl_._has_bits_[1] &= ~0x00080000u;
}
inline ::int32_t DebugOptions::xla_multiheap_size_constraint_per_heap() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_multiheap_size_constraint_per_heap)
  return _internal_xla_multiheap_size_constraint_per_heap();
}
inline void DebugOptions::set_xla_multiheap_size_constraint_per_heap(::int32_t value) {
  _internal_set_xla_multiheap_size_constraint_per_heap(value);
  _impl_._has_bits_[1] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_multiheap_size_constraint_per_heap)
}
inline ::int32_t DebugOptions::_internal_xla_multiheap_size_constraint_per_heap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_multiheap_size_constraint_per_heap_;
}
inline void DebugOptions::_internal_set_xla_multiheap_size_constraint_per_heap(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_multiheap_size_constraint_per_heap_ = value;
}

// optional bool xla_detailed_logging = 252;
inline bool DebugOptions::has_xla_detailed_logging() const {
  bool value = (_impl_._has_bits_[3] & 0x00040000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_detailed_logging() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_detailed_logging_ = false;
  _impl_._has_bits_[3] &= ~0x00040000u;
}
inline bool DebugOptions::xla_detailed_logging() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_detailed_logging)
  return _internal_xla_detailed_logging();
}
inline void DebugOptions::set_xla_detailed_logging(bool value) {
  _internal_set_xla_detailed_logging(value);
  _impl_._has_bits_[3] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_detailed_logging)
}
inline bool DebugOptions::_internal_xla_detailed_logging() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_detailed_logging_;
}
inline void DebugOptions::_internal_set_xla_detailed_logging(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_detailed_logging_ = value;
}

// optional bool xla_enable_dumping = 253;
inline bool DebugOptions::has_xla_enable_dumping() const {
  bool value = (_impl_._has_bits_[3] & 0x00080000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_enable_dumping() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_dumping_ = false;
  _impl_._has_bits_[3] &= ~0x00080000u;
}
inline bool DebugOptions::xla_enable_dumping() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_dumping)
  return _internal_xla_enable_dumping();
}
inline void DebugOptions::set_xla_enable_dumping(bool value) {
  _internal_set_xla_enable_dumping(value);
  _impl_._has_bits_[3] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_dumping)
}
inline bool DebugOptions::_internal_xla_enable_dumping() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_enable_dumping_;
}
inline void DebugOptions::_internal_set_xla_enable_dumping(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_dumping_ = value;
}

// optional bool xla_llvm_force_inline_before_split = 300;
inline bool DebugOptions::has_xla_llvm_force_inline_before_split() const {
  bool value = (_impl_._has_bits_[3] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_llvm_force_inline_before_split() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_force_inline_before_split_ = false;
  _impl_._has_bits_[3] &= ~0x00100000u;
}
inline bool DebugOptions::xla_llvm_force_inline_before_split() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_force_inline_before_split)
  return _internal_xla_llvm_force_inline_before_split();
}
inline void DebugOptions::set_xla_llvm_force_inline_before_split(bool value) {
  _internal_set_xla_llvm_force_inline_before_split(value);
  _impl_._has_bits_[3] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_force_inline_before_split)
}
inline bool DebugOptions::_internal_xla_llvm_force_inline_before_split() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_llvm_force_inline_before_split_;
}
inline void DebugOptions::_internal_set_xla_llvm_force_inline_before_split(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_llvm_force_inline_before_split_ = value;
}

// optional bool xla_dump_disable_metadata = 153;
inline bool DebugOptions::has_xla_dump_disable_metadata() const {
  bool value = (_impl_._has_bits_[3] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_disable_metadata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_disable_metadata_ = false;
  _impl_._has_bits_[3] &= ~0x00200000u;
}
inline bool DebugOptions::xla_dump_disable_metadata() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_disable_metadata)
  return _internal_xla_dump_disable_metadata();
}
inline void DebugOptions::set_xla_dump_disable_metadata(bool value) {
  _internal_set_xla_dump_disable_metadata(value);
  _impl_._has_bits_[3] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_disable_metadata)
}
inline bool DebugOptions::_internal_xla_dump_disable_metadata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_disable_metadata_;
}
inline void DebugOptions::_internal_set_xla_dump_disable_metadata(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_disable_metadata_ = value;
}

// optional string xla_dump_hlo_pipeline_re = 154;
inline bool DebugOptions::has_xla_dump_hlo_pipeline_re() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_hlo_pipeline_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_hlo_pipeline_re_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& DebugOptions::xla_dump_hlo_pipeline_re() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_pipeline_re)
  return _internal_xla_dump_hlo_pipeline_re();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_pipeline_re(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.xla_dump_hlo_pipeline_re_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_pipeline_re)
}
inline std::string* DebugOptions::mutable_xla_dump_hlo_pipeline_re() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_dump_hlo_pipeline_re();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_pipeline_re)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_dump_hlo_pipeline_re() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_hlo_pipeline_re_.Get();
}
inline void DebugOptions::_internal_set_xla_dump_hlo_pipeline_re(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.xla_dump_hlo_pipeline_re_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_pipeline_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.xla_dump_hlo_pipeline_re_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_dump_hlo_pipeline_re() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_pipeline_re)
  if ((_impl_._has_bits_[0] & 0x00000020u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* released = _impl_.xla_dump_hlo_pipeline_re_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_dump_hlo_pipeline_re_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_dump_hlo_pipeline_re(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.xla_dump_hlo_pipeline_re_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_dump_hlo_pipeline_re_.IsDefault()) {
          _impl_.xla_dump_hlo_pipeline_re_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_pipeline_re)
}

// optional bool xla_cpu_use_acl = 174;
inline bool DebugOptions::has_xla_cpu_use_acl() const {
  bool value = (_impl_._has_bits_[2] & 0x00100000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_use_acl() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_acl_ = false;
  _impl_._has_bits_[2] &= ~0x00100000u;
}
inline bool DebugOptions::xla_cpu_use_acl() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_acl)
  return _internal_xla_cpu_use_acl();
}
inline void DebugOptions::set_xla_cpu_use_acl(bool value) {
  _internal_set_xla_cpu_use_acl(value);
  _impl_._has_bits_[2] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_acl)
}
inline bool DebugOptions::_internal_xla_cpu_use_acl() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_use_acl_;
}
inline void DebugOptions::_internal_set_xla_cpu_use_acl(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_use_acl_ = value;
}

// optional bool xla_cpu_strict_dot_conv_math = 175;
inline bool DebugOptions::has_xla_cpu_strict_dot_conv_math() const {
  bool value = (_impl_._has_bits_[2] & 0x00200000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cpu_strict_dot_conv_math() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_strict_dot_conv_math_ = false;
  _impl_._has_bits_[2] &= ~0x00200000u;
}
inline bool DebugOptions::xla_cpu_strict_dot_conv_math() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_strict_dot_conv_math)
  return _internal_xla_cpu_strict_dot_conv_math();
}
inline void DebugOptions::set_xla_cpu_strict_dot_conv_math(bool value) {
  _internal_set_xla_cpu_strict_dot_conv_math(value);
  _impl_._has_bits_[2] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_strict_dot_conv_math)
}
inline bool DebugOptions::_internal_xla_cpu_strict_dot_conv_math() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cpu_strict_dot_conv_math_;
}
inline void DebugOptions::_internal_set_xla_cpu_strict_dot_conv_math(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cpu_strict_dot_conv_math_ = value;
}

// optional bool xla_dump_latency_hiding_schedule = 182;
inline bool DebugOptions::has_xla_dump_latency_hiding_schedule() const {
  bool value = (_impl_._has_bits_[2] & 0x00400000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_latency_hiding_schedule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_latency_hiding_schedule_ = false;
  _impl_._has_bits_[2] &= ~0x00400000u;
}
inline bool DebugOptions::xla_dump_latency_hiding_schedule() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_latency_hiding_schedule)
  return _internal_xla_dump_latency_hiding_schedule();
}
inline void DebugOptions::set_xla_dump_latency_hiding_schedule(bool value) {
  _internal_set_xla_dump_latency_hiding_schedule(value);
  _impl_._has_bits_[2] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_latency_hiding_schedule)
}
inline bool DebugOptions::_internal_xla_dump_latency_hiding_schedule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_latency_hiding_schedule_;
}
inline void DebugOptions::_internal_set_xla_dump_latency_hiding_schedule(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_latency_hiding_schedule_ = value;
}

// optional .xla.DebugOptions.PartitioningAlgorithm xla_partitioning_algorithm = 187;
inline bool DebugOptions::has_xla_partitioning_algorithm() const {
  bool value = (_impl_._has_bits_[2] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_partitioning_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_partitioning_algorithm_ = 0;
  _impl_._has_bits_[2] &= ~0x00004000u;
}
inline ::xla::DebugOptions_PartitioningAlgorithm DebugOptions::xla_partitioning_algorithm() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_partitioning_algorithm)
  return _internal_xla_partitioning_algorithm();
}
inline void DebugOptions::set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value) {
  _internal_set_xla_partitioning_algorithm(value);
  _impl_._has_bits_[2] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_partitioning_algorithm)
}
inline ::xla::DebugOptions_PartitioningAlgorithm DebugOptions::_internal_xla_partitioning_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::DebugOptions_PartitioningAlgorithm>(_impl_.xla_partitioning_algorithm_);
}
inline void DebugOptions::_internal_set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_partitioning_algorithm_ = value;
}

// optional int64 xla_debug_buffer_assignment_show_max = 251;
inline bool DebugOptions::has_xla_debug_buffer_assignment_show_max() const {
  bool value = (_impl_._has_bits_[3] & 0x80000000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_debug_buffer_assignment_show_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_debug_buffer_assignment_show_max_ = ::int64_t{0};
  _impl_._has_bits_[3] &= ~0x80000000u;
}
inline ::int64_t DebugOptions::xla_debug_buffer_assignment_show_max() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_debug_buffer_assignment_show_max)
  return _internal_xla_debug_buffer_assignment_show_max();
}
inline void DebugOptions::set_xla_debug_buffer_assignment_show_max(::int64_t value) {
  _internal_set_xla_debug_buffer_assignment_show_max(value);
  _impl_._has_bits_[3] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_debug_buffer_assignment_show_max)
}
inline ::int64_t DebugOptions::_internal_xla_debug_buffer_assignment_show_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_debug_buffer_assignment_show_max_;
}
inline void DebugOptions::_internal_set_xla_debug_buffer_assignment_show_max(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_debug_buffer_assignment_show_max_ = value;
}

// optional bool xla_dump_large_constants = 290;
inline bool DebugOptions::has_xla_dump_large_constants() const {
  bool value = (_impl_._has_bits_[2] & 0x00800000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_dump_large_constants() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_large_constants_ = false;
  _impl_._has_bits_[2] &= ~0x00800000u;
}
inline bool DebugOptions::xla_dump_large_constants() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_large_constants)
  return _internal_xla_dump_large_constants();
}
inline void DebugOptions::set_xla_dump_large_constants(bool value) {
  _internal_set_xla_dump_large_constants(value);
  _impl_._has_bits_[2] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_large_constants)
}
inline bool DebugOptions::_internal_xla_dump_large_constants() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_dump_large_constants_;
}
inline void DebugOptions::_internal_set_xla_dump_large_constants(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_dump_large_constants_ = value;
}

// optional int64 xla_reduce_window_rewrite_base_length = 293;
inline bool DebugOptions::has_xla_reduce_window_rewrite_base_length() const {
  bool value = (_impl_._has_bits_[5] & 0x00000004u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_reduce_window_rewrite_base_length() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_reduce_window_rewrite_base_length_ = ::int64_t{0};
  _impl_._has_bits_[5] &= ~0x00000004u;
}
inline ::int64_t DebugOptions::xla_reduce_window_rewrite_base_length() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_reduce_window_rewrite_base_length)
  return _internal_xla_reduce_window_rewrite_base_length();
}
inline void DebugOptions::set_xla_reduce_window_rewrite_base_length(::int64_t value) {
  _internal_set_xla_reduce_window_rewrite_base_length(value);
  _impl_._has_bits_[5] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_reduce_window_rewrite_base_length)
}
inline ::int64_t DebugOptions::_internal_xla_reduce_window_rewrite_base_length() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_reduce_window_rewrite_base_length_;
}
inline void DebugOptions::_internal_set_xla_reduce_window_rewrite_base_length(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_reduce_window_rewrite_base_length_ = value;
}

// optional int64 xla_cmd_buffer_trace_cache_size = 311;
inline bool DebugOptions::has_xla_cmd_buffer_trace_cache_size() const {
  bool value = (_impl_._has_bits_[5] & 0x00000008u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_cmd_buffer_trace_cache_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cmd_buffer_trace_cache_size_ = ::int64_t{0};
  _impl_._has_bits_[5] &= ~0x00000008u;
}
inline ::int64_t DebugOptions::xla_cmd_buffer_trace_cache_size() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cmd_buffer_trace_cache_size)
  return _internal_xla_cmd_buffer_trace_cache_size();
}
inline void DebugOptions::set_xla_cmd_buffer_trace_cache_size(::int64_t value) {
  _internal_set_xla_cmd_buffer_trace_cache_size(value);
  _impl_._has_bits_[5] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cmd_buffer_trace_cache_size)
}
inline ::int64_t DebugOptions::_internal_xla_cmd_buffer_trace_cache_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_cmd_buffer_trace_cache_size_;
}
inline void DebugOptions::_internal_set_xla_cmd_buffer_trace_cache_size(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_cmd_buffer_trace_cache_size_ = value;
}

// repeated string legacy_command_buffer_custom_call_targets = 314;
inline int DebugOptions::_internal_legacy_command_buffer_custom_call_targets_size() const {
  return _internal_legacy_command_buffer_custom_call_targets().size();
}
inline int DebugOptions::legacy_command_buffer_custom_call_targets_size() const {
  return _internal_legacy_command_buffer_custom_call_targets_size();
}
inline void DebugOptions::clear_legacy_command_buffer_custom_call_targets() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.legacy_command_buffer_custom_call_targets_.Clear();
}
inline std::string* DebugOptions::add_legacy_command_buffer_custom_call_targets() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_legacy_command_buffer_custom_call_targets()->Add();
  // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
  return _s;
}
inline const std::string& DebugOptions::legacy_command_buffer_custom_call_targets(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
  return _internal_legacy_command_buffer_custom_call_targets().Get(index);
}
inline std::string* DebugOptions::mutable_legacy_command_buffer_custom_call_targets(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
  return _internal_mutable_legacy_command_buffer_custom_call_targets()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::set_legacy_command_buffer_custom_call_targets(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_legacy_command_buffer_custom_call_targets()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
}
template <typename Arg_, typename... Args_>
inline void DebugOptions::add_legacy_command_buffer_custom_call_targets(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_legacy_command_buffer_custom_call_targets(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::legacy_command_buffer_custom_call_targets() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
  return _internal_legacy_command_buffer_custom_call_targets();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::mutable_legacy_command_buffer_custom_call_targets() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.legacy_command_buffer_custom_call_targets)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_legacy_command_buffer_custom_call_targets();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
DebugOptions::_internal_legacy_command_buffer_custom_call_targets() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.legacy_command_buffer_custom_call_targets_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
DebugOptions::_internal_mutable_legacy_command_buffer_custom_call_targets() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.legacy_command_buffer_custom_call_targets_;
}

// optional bool xla_syntax_sugar_async_ops = 315;
inline bool DebugOptions::has_xla_syntax_sugar_async_ops() const {
  bool value = (_impl_._has_bits_[5] & 0x00002000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_syntax_sugar_async_ops() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_syntax_sugar_async_ops_ = false;
  _impl_._has_bits_[5] &= ~0x00002000u;
}
inline bool DebugOptions::xla_syntax_sugar_async_ops() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_syntax_sugar_async_ops)
  return _internal_xla_syntax_sugar_async_ops();
}
inline void DebugOptions::set_xla_syntax_sugar_async_ops(bool value) {
  _internal_set_xla_syntax_sugar_async_ops(value);
  _impl_._has_bits_[5] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_syntax_sugar_async_ops)
}
inline bool DebugOptions::_internal_xla_syntax_sugar_async_ops() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_syntax_sugar_async_ops_;
}
inline void DebugOptions::_internal_set_xla_syntax_sugar_async_ops(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_syntax_sugar_async_ops_ = value;
}

// optional bool xla_enable_command_buffers_during_profiling = 317;
inline bool DebugOptions::has_xla_enable_command_buffers_during_profiling() const {
  bool value = (_impl_._has_bits_[5] & 0x00004000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_enable_command_buffers_during_profiling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_command_buffers_during_profiling_ = false;
  _impl_._has_bits_[5] &= ~0x00004000u;
}
inline bool DebugOptions::xla_enable_command_buffers_during_profiling() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_command_buffers_during_profiling)
  return _internal_xla_enable_command_buffers_during_profiling();
}
inline void DebugOptions::set_xla_enable_command_buffers_during_profiling(bool value) {
  _internal_set_xla_enable_command_buffers_during_profiling(value);
  _impl_._has_bits_[5] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_command_buffers_during_profiling)
}
inline bool DebugOptions::_internal_xla_enable_command_buffers_during_profiling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_enable_command_buffers_during_profiling_;
}
inline void DebugOptions::_internal_set_xla_enable_command_buffers_during_profiling(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_enable_command_buffers_during_profiling_ = value;
}

// optional bool xla_ignore_channel_id = 330;
inline bool DebugOptions::has_xla_ignore_channel_id() const {
  bool value = (_impl_._has_bits_[5] & 0x00008000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_ignore_channel_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_ignore_channel_id_ = false;
  _impl_._has_bits_[5] &= ~0x00008000u;
}
inline bool DebugOptions::xla_ignore_channel_id() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_ignore_channel_id)
  return _internal_xla_ignore_channel_id();
}
inline void DebugOptions::set_xla_ignore_channel_id(bool value) {
  _internal_set_xla_ignore_channel_id(value);
  _impl_._has_bits_[5] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_ignore_channel_id)
}
inline bool DebugOptions::_internal_xla_ignore_channel_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_ignore_channel_id_;
}
inline void DebugOptions::_internal_set_xla_ignore_channel_id(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_ignore_channel_id_ = value;
}

// optional bool xla_pjrt_allow_auto_layout_in_hlo = 344;
inline bool DebugOptions::has_xla_pjrt_allow_auto_layout_in_hlo() const {
  bool value = (_impl_._has_bits_[5] & 0x00010000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_pjrt_allow_auto_layout_in_hlo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_pjrt_allow_auto_layout_in_hlo_ = false;
  _impl_._has_bits_[5] &= ~0x00010000u;
}
inline bool DebugOptions::xla_pjrt_allow_auto_layout_in_hlo() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_pjrt_allow_auto_layout_in_hlo)
  return _internal_xla_pjrt_allow_auto_layout_in_hlo();
}
inline void DebugOptions::set_xla_pjrt_allow_auto_layout_in_hlo(bool value) {
  _internal_set_xla_pjrt_allow_auto_layout_in_hlo(value);
  _impl_._has_bits_[5] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_pjrt_allow_auto_layout_in_hlo)
}
inline bool DebugOptions::_internal_xla_pjrt_allow_auto_layout_in_hlo() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_pjrt_allow_auto_layout_in_hlo_;
}
inline void DebugOptions::_internal_set_xla_pjrt_allow_auto_layout_in_hlo(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_pjrt_allow_auto_layout_in_hlo_ = value;
}

// optional bool xla_test_add_command_buffer_mode = 373;
inline bool DebugOptions::has_xla_test_add_command_buffer_mode() const {
  bool value = (_impl_._has_bits_[7] & 0x00000001u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_test_add_command_buffer_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_add_command_buffer_mode_ = false;
  _impl_._has_bits_[7] &= ~0x00000001u;
}
inline bool DebugOptions::xla_test_add_command_buffer_mode() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_test_add_command_buffer_mode)
  return _internal_xla_test_add_command_buffer_mode();
}
inline void DebugOptions::set_xla_test_add_command_buffer_mode(bool value) {
  _internal_set_xla_test_add_command_buffer_mode(value);
  _impl_._has_bits_[7] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_test_add_command_buffer_mode)
}
inline bool DebugOptions::_internal_xla_test_add_command_buffer_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_test_add_command_buffer_mode_;
}
inline void DebugOptions::_internal_set_xla_test_add_command_buffer_mode(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_test_add_command_buffer_mode_ = value;
}

// optional string xla_gpu_experimental_matmul_perf_table_path = 383;
inline bool DebugOptions::has_xla_gpu_experimental_matmul_perf_table_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_gpu_experimental_matmul_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_gpu_experimental_matmul_perf_table_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const std::string& DebugOptions::xla_gpu_experimental_matmul_perf_table_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_matmul_perf_table_path)
  return _internal_xla_gpu_experimental_matmul_perf_table_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_experimental_matmul_perf_table_path(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.xla_gpu_experimental_matmul_perf_table_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_matmul_perf_table_path)
}
inline std::string* DebugOptions::mutable_xla_gpu_experimental_matmul_perf_table_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_xla_gpu_experimental_matmul_perf_table_path();
  // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_experimental_matmul_perf_table_path)
  return _s;
}
inline const std::string& DebugOptions::_internal_xla_gpu_experimental_matmul_perf_table_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_gpu_experimental_matmul_perf_table_path_.Get();
}
inline void DebugOptions::_internal_set_xla_gpu_experimental_matmul_perf_table_path(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.xla_gpu_experimental_matmul_perf_table_path_.Set(value, GetArena());
}
inline std::string* DebugOptions::_internal_mutable_xla_gpu_experimental_matmul_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00020000u;
  return _impl_.xla_gpu_experimental_matmul_perf_table_path_.Mutable( GetArena());
}
inline std::string* DebugOptions::release_xla_gpu_experimental_matmul_perf_table_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_experimental_matmul_perf_table_path)
  if ((_impl_._has_bits_[0] & 0x00020000u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00020000u;
  auto* released = _impl_.xla_gpu_experimental_matmul_perf_table_path_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.xla_gpu_experimental_matmul_perf_table_path_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void DebugOptions::set_allocated_xla_gpu_experimental_matmul_perf_table_path(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.xla_gpu_experimental_matmul_perf_table_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.xla_gpu_experimental_matmul_perf_table_path_.IsDefault()) {
          _impl_.xla_gpu_experimental_matmul_perf_table_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_experimental_matmul_perf_table_path)
}

// optional bool xla_early_exit_with_layouts = 397;
inline bool DebugOptions::has_xla_early_exit_with_layouts() const {
  bool value = (_impl_._has_bits_[7] & 0x00000002u) != 0;
  return value;
}
inline void DebugOptions::clear_xla_early_exit_with_layouts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_early_exit_with_layouts_ = false;
  _impl_._has_bits_[7] &= ~0x00000002u;
}
inline bool DebugOptions::xla_early_exit_with_layouts() const {
  // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_early_exit_with_layouts)
  return _internal_xla_early_exit_with_layouts();
}
inline void DebugOptions::set_xla_early_exit_with_layouts(bool value) {
  _internal_set_xla_early_exit_with_layouts(value);
  _impl_._has_bits_[7] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_early_exit_with_layouts)
}
inline bool DebugOptions::_internal_xla_early_exit_with_layouts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_early_exit_with_layouts_;
}
inline void DebugOptions::_internal_set_xla_early_exit_with_layouts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_early_exit_with_layouts_ = value;
}

// map<string, string> xla_backend_extra_options = 500;
inline int DebugOptions::_internal_xla_backend_extra_options_size() const {
  return _internal_xla_backend_extra_options().size();
}
inline int DebugOptions::xla_backend_extra_options_size() const {
  return _internal_xla_backend_extra_options_size();
}
inline void DebugOptions::clear_xla_backend_extra_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.xla_backend_extra_options_.Clear();
}
inline const ::google::protobuf::Map<std::string, std::string>& DebugOptions::_internal_xla_backend_extra_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.xla_backend_extra_options_.GetMap();
}
inline const ::google::protobuf::Map<std::string, std::string>& DebugOptions::xla_backend_extra_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:xla.DebugOptions.xla_backend_extra_options)
  return _internal_xla_backend_extra_options();
}
inline ::google::protobuf::Map<std::string, std::string>* DebugOptions::_internal_mutable_xla_backend_extra_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.xla_backend_extra_options_.MutableMap();
}
inline ::google::protobuf::Map<std::string, std::string>* DebugOptions::mutable_xla_backend_extra_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:xla.DebugOptions.xla_backend_extra_options)
  return _internal_mutable_xla_backend_extra_options();
}

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

// GpuCompilationEnvironment

// int64 dummy_flag = 1;
inline void GpuCompilationEnvironment::clear_dummy_flag() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dummy_flag_ = ::int64_t{0};
}
inline ::int64_t GpuCompilationEnvironment::dummy_flag() const {
  // @@protoc_insertion_point(field_get:xla.GpuCompilationEnvironment.dummy_flag)
  return _internal_dummy_flag();
}
inline void GpuCompilationEnvironment::set_dummy_flag(::int64_t value) {
  _internal_set_dummy_flag(value);
  // @@protoc_insertion_point(field_set:xla.GpuCompilationEnvironment.dummy_flag)
}
inline ::int64_t GpuCompilationEnvironment::_internal_dummy_flag() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dummy_flag_;
}
inline void GpuCompilationEnvironment::_internal_set_dummy_flag(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dummy_flag_ = value;
}

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

// ShardableValueUpdatePairProto

// int64 input_parameter_number = 1;
inline void ShardableValueUpdatePairProto::clear_input_parameter_number() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_parameter_number_ = ::int64_t{0};
}
inline ::int64_t ShardableValueUpdatePairProto::input_parameter_number() const {
  // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.input_parameter_number)
  return _internal_input_parameter_number();
}
inline void ShardableValueUpdatePairProto::set_input_parameter_number(::int64_t value) {
  _internal_set_input_parameter_number(value);
  // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.input_parameter_number)
}
inline ::int64_t ShardableValueUpdatePairProto::_internal_input_parameter_number() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_parameter_number_;
}
inline void ShardableValueUpdatePairProto::_internal_set_input_parameter_number(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_parameter_number_ = value;
}

// repeated int64 parameter_shape_index = 2;
inline int ShardableValueUpdatePairProto::_internal_parameter_shape_index_size() const {
  return _internal_parameter_shape_index().size();
}
inline int ShardableValueUpdatePairProto::parameter_shape_index_size() const {
  return _internal_parameter_shape_index_size();
}
inline void ShardableValueUpdatePairProto::clear_parameter_shape_index() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.parameter_shape_index_.Clear();
}
inline ::int64_t ShardableValueUpdatePairProto::parameter_shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.parameter_shape_index)
  return _internal_parameter_shape_index().Get(index);
}
inline void ShardableValueUpdatePairProto::set_parameter_shape_index(int index, ::int64_t value) {
  _internal_mutable_parameter_shape_index()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.parameter_shape_index)
}
inline void ShardableValueUpdatePairProto::add_parameter_shape_index(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_parameter_shape_index()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ShardableValueUpdatePairProto.parameter_shape_index)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& ShardableValueUpdatePairProto::parameter_shape_index() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ShardableValueUpdatePairProto.parameter_shape_index)
  return _internal_parameter_shape_index();
}
inline ::google::protobuf::RepeatedField<::int64_t>* ShardableValueUpdatePairProto::mutable_parameter_shape_index()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ShardableValueUpdatePairProto.parameter_shape_index)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_parameter_shape_index();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
ShardableValueUpdatePairProto::_internal_parameter_shape_index() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.parameter_shape_index_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* ShardableValueUpdatePairProto::_internal_mutable_parameter_shape_index() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.parameter_shape_index_;
}

// repeated int64 output_shape_index = 3;
inline int ShardableValueUpdatePairProto::_internal_output_shape_index_size() const {
  return _internal_output_shape_index().size();
}
inline int ShardableValueUpdatePairProto::output_shape_index_size() const {
  return _internal_output_shape_index_size();
}
inline void ShardableValueUpdatePairProto::clear_output_shape_index() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_shape_index_.Clear();
}
inline ::int64_t ShardableValueUpdatePairProto::output_shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.output_shape_index)
  return _internal_output_shape_index().Get(index);
}
inline void ShardableValueUpdatePairProto::set_output_shape_index(int index, ::int64_t value) {
  _internal_mutable_output_shape_index()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.output_shape_index)
}
inline void ShardableValueUpdatePairProto::add_output_shape_index(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_output_shape_index()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ShardableValueUpdatePairProto.output_shape_index)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& ShardableValueUpdatePairProto::output_shape_index() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ShardableValueUpdatePairProto.output_shape_index)
  return _internal_output_shape_index();
}
inline ::google::protobuf::RepeatedField<::int64_t>* ShardableValueUpdatePairProto::mutable_output_shape_index()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ShardableValueUpdatePairProto.output_shape_index)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_output_shape_index();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
ShardableValueUpdatePairProto::_internal_output_shape_index() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_shape_index_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* ShardableValueUpdatePairProto::_internal_mutable_output_shape_index() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.output_shape_index_;
}

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

// ExecutionOptions

// .xla.ShapeProto shape_with_output_layout = 2;
inline bool ExecutionOptions::has_shape_with_output_layout() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.shape_with_output_layout_ != nullptr);
  return value;
}
inline const ::xla::ShapeProto& ExecutionOptions::_internal_shape_with_output_layout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::ShapeProto* p = _impl_.shape_with_output_layout_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ShapeProto&>(::xla::_ShapeProto_default_instance_);
}
inline const ::xla::ShapeProto& ExecutionOptions::shape_with_output_layout() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.shape_with_output_layout)
  return _internal_shape_with_output_layout();
}
inline void ExecutionOptions::unsafe_arena_set_allocated_shape_with_output_layout(::xla::ShapeProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_with_output_layout_);
  }
  _impl_.shape_with_output_layout_ = reinterpret_cast<::xla::ShapeProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.shape_with_output_layout)
}
inline ::xla::ShapeProto* ExecutionOptions::release_shape_with_output_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ShapeProto* released = _impl_.shape_with_output_layout_;
  _impl_.shape_with_output_layout_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::ShapeProto* ExecutionOptions::unsafe_arena_release_shape_with_output_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ExecutionOptions.shape_with_output_layout)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ShapeProto* temp = _impl_.shape_with_output_layout_;
  _impl_.shape_with_output_layout_ = nullptr;
  return temp;
}
inline ::xla::ShapeProto* ExecutionOptions::_internal_mutable_shape_with_output_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.shape_with_output_layout_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::ShapeProto>(GetArena());
    _impl_.shape_with_output_layout_ = reinterpret_cast<::xla::ShapeProto*>(p);
  }
  return _impl_.shape_with_output_layout_;
}
inline ::xla::ShapeProto* ExecutionOptions::mutable_shape_with_output_layout() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::ShapeProto* _msg = _internal_mutable_shape_with_output_layout();
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.shape_with_output_layout)
  return _msg;
}
inline void ExecutionOptions::set_allocated_shape_with_output_layout(::xla::ShapeProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_with_output_layout_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.shape_with_output_layout_ = reinterpret_cast<::xla::ShapeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.shape_with_output_layout)
}

// uint64 seed = 3;
inline void ExecutionOptions::clear_seed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_ = ::uint64_t{0u};
}
inline ::uint64_t ExecutionOptions::seed() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.seed)
  return _internal_seed();
}
inline void ExecutionOptions::set_seed(::uint64_t value) {
  _internal_set_seed(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.seed)
}
inline ::uint64_t ExecutionOptions::_internal_seed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seed_;
}
inline void ExecutionOptions::_internal_set_seed(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_ = value;
}

// .xla.DebugOptions debug_options = 4;
inline bool ExecutionOptions::has_debug_options() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.debug_options_ != nullptr);
  return value;
}
inline void ExecutionOptions::clear_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.debug_options_ != nullptr) _impl_.debug_options_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::xla::DebugOptions& ExecutionOptions::_internal_debug_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::DebugOptions* p = _impl_.debug_options_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DebugOptions&>(::xla::_DebugOptions_default_instance_);
}
inline const ::xla::DebugOptions& ExecutionOptions::debug_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.debug_options)
  return _internal_debug_options();
}
inline void ExecutionOptions::unsafe_arena_set_allocated_debug_options(::xla::DebugOptions* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.debug_options_);
  }
  _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.debug_options)
}
inline ::xla::DebugOptions* ExecutionOptions::release_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::DebugOptions* released = _impl_.debug_options_;
  _impl_.debug_options_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::DebugOptions* ExecutionOptions::unsafe_arena_release_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ExecutionOptions.debug_options)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::DebugOptions* temp = _impl_.debug_options_;
  _impl_.debug_options_ = nullptr;
  return temp;
}
inline ::xla::DebugOptions* ExecutionOptions::_internal_mutable_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.debug_options_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::DebugOptions>(GetArena());
    _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(p);
  }
  return _impl_.debug_options_;
}
inline ::xla::DebugOptions* ExecutionOptions::mutable_debug_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::xla::DebugOptions* _msg = _internal_mutable_debug_options();
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.debug_options)
  return _msg;
}
inline void ExecutionOptions::set_allocated_debug_options(::xla::DebugOptions* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.debug_options_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.debug_options)
}

// repeated .xla.DeviceHandle device_handles = 5;
inline int ExecutionOptions::_internal_device_handles_size() const {
  return _internal_device_handles().size();
}
inline int ExecutionOptions::device_handles_size() const {
  return _internal_device_handles_size();
}
inline ::xla::DeviceHandle* ExecutionOptions::mutable_device_handles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.device_handles)
  return _internal_mutable_device_handles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>* ExecutionOptions::mutable_device_handles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.device_handles)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_device_handles();
}
inline const ::xla::DeviceHandle& ExecutionOptions::device_handles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_handles)
  return _internal_device_handles().Get(index);
}
inline ::xla::DeviceHandle* ExecutionOptions::add_device_handles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::DeviceHandle* _add = _internal_mutable_device_handles()->Add();
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.device_handles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>& ExecutionOptions::device_handles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.device_handles)
  return _internal_device_handles();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>&
ExecutionOptions::_internal_device_handles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_handles_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::DeviceHandle>*
ExecutionOptions::_internal_mutable_device_handles() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.device_handles_;
}

// int32 num_replicas = 6;
inline void ExecutionOptions::clear_num_replicas() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_replicas_ = 0;
}
inline ::int32_t ExecutionOptions::num_replicas() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.num_replicas)
  return _internal_num_replicas();
}
inline void ExecutionOptions::set_num_replicas(::int32_t value) {
  _internal_set_num_replicas(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.num_replicas)
}
inline ::int32_t ExecutionOptions::_internal_num_replicas() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_replicas_;
}
inline void ExecutionOptions::_internal_set_num_replicas(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_replicas_ = value;
}

// .xla.DeviceAssignmentProto device_assignment = 7;
inline bool ExecutionOptions::has_device_assignment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.device_assignment_ != nullptr);
  return value;
}
inline const ::xla::DeviceAssignmentProto& ExecutionOptions::_internal_device_assignment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::DeviceAssignmentProto* p = _impl_.device_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DeviceAssignmentProto&>(::xla::_DeviceAssignmentProto_default_instance_);
}
inline const ::xla::DeviceAssignmentProto& ExecutionOptions::device_assignment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_assignment)
  return _internal_device_assignment();
}
inline void ExecutionOptions::unsafe_arena_set_allocated_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.device_assignment_);
  }
  _impl_.device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.device_assignment)
}
inline ::xla::DeviceAssignmentProto* ExecutionOptions::release_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::xla::DeviceAssignmentProto* released = _impl_.device_assignment_;
  _impl_.device_assignment_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::DeviceAssignmentProto* ExecutionOptions::unsafe_arena_release_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ExecutionOptions.device_assignment)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::xla::DeviceAssignmentProto* temp = _impl_.device_assignment_;
  _impl_.device_assignment_ = nullptr;
  return temp;
}
inline ::xla::DeviceAssignmentProto* ExecutionOptions::_internal_mutable_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.device_assignment_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::DeviceAssignmentProto>(GetArena());
    _impl_.device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(p);
  }
  return _impl_.device_assignment_;
}
inline ::xla::DeviceAssignmentProto* ExecutionOptions::mutable_device_assignment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000004u;
  ::xla::DeviceAssignmentProto* _msg = _internal_mutable_device_assignment();
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.device_assignment)
  return _msg;
}
inline void ExecutionOptions::set_allocated_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.device_assignment_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.device_assignment)
}

// bool alias_passthrough_params = 8;
inline void ExecutionOptions::clear_alias_passthrough_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alias_passthrough_params_ = false;
}
inline bool ExecutionOptions::alias_passthrough_params() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.alias_passthrough_params)
  return _internal_alias_passthrough_params();
}
inline void ExecutionOptions::set_alias_passthrough_params(bool value) {
  _internal_set_alias_passthrough_params(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.alias_passthrough_params)
}
inline bool ExecutionOptions::_internal_alias_passthrough_params() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alias_passthrough_params_;
}
inline void ExecutionOptions::_internal_set_alias_passthrough_params(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alias_passthrough_params_ = value;
}

// int32 num_partitions = 9;
inline void ExecutionOptions::clear_num_partitions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_partitions_ = 0;
}
inline ::int32_t ExecutionOptions::num_partitions() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.num_partitions)
  return _internal_num_partitions();
}
inline void ExecutionOptions::set_num_partitions(::int32_t value) {
  _internal_set_num_partitions(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.num_partitions)
}
inline ::int32_t ExecutionOptions::_internal_num_partitions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_partitions_;
}
inline void ExecutionOptions::_internal_set_num_partitions(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_partitions_ = value;
}

// int32 launch_id = 10;
inline void ExecutionOptions::clear_launch_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.launch_id_ = 0;
}
inline ::int32_t ExecutionOptions::launch_id() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.launch_id)
  return _internal_launch_id();
}
inline void ExecutionOptions::set_launch_id(::int32_t value) {
  _internal_set_launch_id(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.launch_id)
}
inline ::int32_t ExecutionOptions::_internal_launch_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.launch_id_;
}
inline void ExecutionOptions::_internal_set_launch_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.launch_id_ = value;
}

// bool use_spmd_partitioning = 11;
inline void ExecutionOptions::clear_use_spmd_partitioning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_spmd_partitioning_ = false;
}
inline bool ExecutionOptions::use_spmd_partitioning() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_spmd_partitioning)
  return _internal_use_spmd_partitioning();
}
inline void ExecutionOptions::set_use_spmd_partitioning(bool value) {
  _internal_set_use_spmd_partitioning(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_spmd_partitioning)
}
inline bool ExecutionOptions::_internal_use_spmd_partitioning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_spmd_partitioning_;
}
inline void ExecutionOptions::_internal_set_use_spmd_partitioning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_spmd_partitioning_ = value;
}

// bool use_auto_spmd_partitioning = 15;
inline void ExecutionOptions::clear_use_auto_spmd_partitioning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_auto_spmd_partitioning_ = false;
}
inline bool ExecutionOptions::use_auto_spmd_partitioning() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_auto_spmd_partitioning)
  return _internal_use_auto_spmd_partitioning();
}
inline void ExecutionOptions::set_use_auto_spmd_partitioning(bool value) {
  _internal_set_use_auto_spmd_partitioning(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_auto_spmd_partitioning)
}
inline bool ExecutionOptions::_internal_use_auto_spmd_partitioning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_auto_spmd_partitioning_;
}
inline void ExecutionOptions::_internal_set_use_auto_spmd_partitioning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_auto_spmd_partitioning_ = value;
}

// repeated int64 auto_spmd_partitioning_mesh_shape = 16;
inline int ExecutionOptions::_internal_auto_spmd_partitioning_mesh_shape_size() const {
  return _internal_auto_spmd_partitioning_mesh_shape().size();
}
inline int ExecutionOptions::auto_spmd_partitioning_mesh_shape_size() const {
  return _internal_auto_spmd_partitioning_mesh_shape_size();
}
inline void ExecutionOptions::clear_auto_spmd_partitioning_mesh_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_spmd_partitioning_mesh_shape_.Clear();
}
inline ::int64_t ExecutionOptions::auto_spmd_partitioning_mesh_shape(int index) const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape)
  return _internal_auto_spmd_partitioning_mesh_shape().Get(index);
}
inline void ExecutionOptions::set_auto_spmd_partitioning_mesh_shape(int index, ::int64_t value) {
  _internal_mutable_auto_spmd_partitioning_mesh_shape()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape)
}
inline void ExecutionOptions::add_auto_spmd_partitioning_mesh_shape(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_auto_spmd_partitioning_mesh_shape()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& ExecutionOptions::auto_spmd_partitioning_mesh_shape() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape)
  return _internal_auto_spmd_partitioning_mesh_shape();
}
inline ::google::protobuf::RepeatedField<::int64_t>* ExecutionOptions::mutable_auto_spmd_partitioning_mesh_shape()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_auto_spmd_partitioning_mesh_shape();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
ExecutionOptions::_internal_auto_spmd_partitioning_mesh_shape() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auto_spmd_partitioning_mesh_shape_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* ExecutionOptions::_internal_mutable_auto_spmd_partitioning_mesh_shape() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.auto_spmd_partitioning_mesh_shape_;
}

// repeated int64 auto_spmd_partitioning_mesh_ids = 17;
inline int ExecutionOptions::_internal_auto_spmd_partitioning_mesh_ids_size() const {
  return _internal_auto_spmd_partitioning_mesh_ids().size();
}
inline int ExecutionOptions::auto_spmd_partitioning_mesh_ids_size() const {
  return _internal_auto_spmd_partitioning_mesh_ids_size();
}
inline void ExecutionOptions::clear_auto_spmd_partitioning_mesh_ids() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_spmd_partitioning_mesh_ids_.Clear();
}
inline ::int64_t ExecutionOptions::auto_spmd_partitioning_mesh_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids)
  return _internal_auto_spmd_partitioning_mesh_ids().Get(index);
}
inline void ExecutionOptions::set_auto_spmd_partitioning_mesh_ids(int index, ::int64_t value) {
  _internal_mutable_auto_spmd_partitioning_mesh_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids)
}
inline void ExecutionOptions::add_auto_spmd_partitioning_mesh_ids(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_auto_spmd_partitioning_mesh_ids()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& ExecutionOptions::auto_spmd_partitioning_mesh_ids() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids)
  return _internal_auto_spmd_partitioning_mesh_ids();
}
inline ::google::protobuf::RepeatedField<::int64_t>* ExecutionOptions::mutable_auto_spmd_partitioning_mesh_ids()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_auto_spmd_partitioning_mesh_ids();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
ExecutionOptions::_internal_auto_spmd_partitioning_mesh_ids() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auto_spmd_partitioning_mesh_ids_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* ExecutionOptions::_internal_mutable_auto_spmd_partitioning_mesh_ids() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.auto_spmd_partitioning_mesh_ids_;
}

// float exec_time_optimization_effort = 25 [deprecated = true];
inline void ExecutionOptions::clear_exec_time_optimization_effort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_time_optimization_effort_ = 0;
}
inline float ExecutionOptions::exec_time_optimization_effort() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.exec_time_optimization_effort)
  return _internal_exec_time_optimization_effort();
}
inline void ExecutionOptions::set_exec_time_optimization_effort(float value) {
  _internal_set_exec_time_optimization_effort(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.exec_time_optimization_effort)
}
inline float ExecutionOptions::_internal_exec_time_optimization_effort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exec_time_optimization_effort_;
}
inline void ExecutionOptions::_internal_set_exec_time_optimization_effort(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_time_optimization_effort_ = value;
}

// float memory_fitting_effort = 26 [deprecated = true];
inline void ExecutionOptions::clear_memory_fitting_effort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_effort_ = 0;
}
inline float ExecutionOptions::memory_fitting_effort() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.memory_fitting_effort)
  return _internal_memory_fitting_effort();
}
inline void ExecutionOptions::set_memory_fitting_effort(float value) {
  _internal_set_memory_fitting_effort(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.memory_fitting_effort)
}
inline float ExecutionOptions::_internal_memory_fitting_effort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.memory_fitting_effort_;
}
inline void ExecutionOptions::_internal_set_memory_fitting_effort(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_effort_ = value;
}

// .xla.ExecutionOptions.EffortLevel optimization_level = 27;
inline void ExecutionOptions::clear_optimization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimization_level_ = 0;
}
inline ::xla::ExecutionOptions_EffortLevel ExecutionOptions::optimization_level() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.optimization_level)
  return _internal_optimization_level();
}
inline void ExecutionOptions::set_optimization_level(::xla::ExecutionOptions_EffortLevel value) {
  _internal_set_optimization_level(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.optimization_level)
}
inline ::xla::ExecutionOptions_EffortLevel ExecutionOptions::_internal_optimization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::ExecutionOptions_EffortLevel>(_impl_.optimization_level_);
}
inline void ExecutionOptions::_internal_set_optimization_level(::xla::ExecutionOptions_EffortLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimization_level_ = value;
}

// .xla.ExecutionOptions.EffortLevel memory_fitting_level = 28;
inline void ExecutionOptions::clear_memory_fitting_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_level_ = 0;
}
inline ::xla::ExecutionOptions_EffortLevel ExecutionOptions::memory_fitting_level() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.memory_fitting_level)
  return _internal_memory_fitting_level();
}
inline void ExecutionOptions::set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value) {
  _internal_set_memory_fitting_level(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.memory_fitting_level)
}
inline ::xla::ExecutionOptions_EffortLevel ExecutionOptions::_internal_memory_fitting_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::ExecutionOptions_EffortLevel>(_impl_.memory_fitting_level_);
}
inline void ExecutionOptions::_internal_set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_level_ = value;
}

// bool deduplicate_hlo = 12;
inline void ExecutionOptions::clear_deduplicate_hlo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.deduplicate_hlo_ = false;
}
inline bool ExecutionOptions::deduplicate_hlo() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.deduplicate_hlo)
  return _internal_deduplicate_hlo();
}
inline void ExecutionOptions::set_deduplicate_hlo(bool value) {
  _internal_set_deduplicate_hlo(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.deduplicate_hlo)
}
inline bool ExecutionOptions::_internal_deduplicate_hlo() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.deduplicate_hlo_;
}
inline void ExecutionOptions::_internal_set_deduplicate_hlo(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.deduplicate_hlo_ = value;
}

// repeated bool allow_spmd_sharding_propagation_to_parameters = 23;
inline int ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_parameters_size() const {
  return _internal_allow_spmd_sharding_propagation_to_parameters().size();
}
inline int ExecutionOptions::allow_spmd_sharding_propagation_to_parameters_size() const {
  return _internal_allow_spmd_sharding_propagation_to_parameters_size();
}
inline void ExecutionOptions::clear_allow_spmd_sharding_propagation_to_parameters() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_spmd_sharding_propagation_to_parameters_.Clear();
}
inline bool ExecutionOptions::allow_spmd_sharding_propagation_to_parameters(int index) const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters)
  return _internal_allow_spmd_sharding_propagation_to_parameters().Get(index);
}
inline void ExecutionOptions::set_allow_spmd_sharding_propagation_to_parameters(int index, bool value) {
  _internal_mutable_allow_spmd_sharding_propagation_to_parameters()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters)
}
inline void ExecutionOptions::add_allow_spmd_sharding_propagation_to_parameters(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_allow_spmd_sharding_propagation_to_parameters()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters)
}
inline const ::google::protobuf::RepeatedField<bool>& ExecutionOptions::allow_spmd_sharding_propagation_to_parameters() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters)
  return _internal_allow_spmd_sharding_propagation_to_parameters();
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::mutable_allow_spmd_sharding_propagation_to_parameters()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_allow_spmd_sharding_propagation_to_parameters();
}
inline const ::google::protobuf::RepeatedField<bool>&
ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_parameters() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_spmd_sharding_propagation_to_parameters_;
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::_internal_mutable_allow_spmd_sharding_propagation_to_parameters() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.allow_spmd_sharding_propagation_to_parameters_;
}

// repeated bool allow_spmd_sharding_propagation_to_output = 14;
inline int ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_output_size() const {
  return _internal_allow_spmd_sharding_propagation_to_output().size();
}
inline int ExecutionOptions::allow_spmd_sharding_propagation_to_output_size() const {
  return _internal_allow_spmd_sharding_propagation_to_output_size();
}
inline void ExecutionOptions::clear_allow_spmd_sharding_propagation_to_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_spmd_sharding_propagation_to_output_.Clear();
}
inline bool ExecutionOptions::allow_spmd_sharding_propagation_to_output(int index) const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output)
  return _internal_allow_spmd_sharding_propagation_to_output().Get(index);
}
inline void ExecutionOptions::set_allow_spmd_sharding_propagation_to_output(int index, bool value) {
  _internal_mutable_allow_spmd_sharding_propagation_to_output()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output)
}
inline void ExecutionOptions::add_allow_spmd_sharding_propagation_to_output(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_allow_spmd_sharding_propagation_to_output()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output)
}
inline const ::google::protobuf::RepeatedField<bool>& ExecutionOptions::allow_spmd_sharding_propagation_to_output() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output)
  return _internal_allow_spmd_sharding_propagation_to_output();
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::mutable_allow_spmd_sharding_propagation_to_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_allow_spmd_sharding_propagation_to_output();
}
inline const ::google::protobuf::RepeatedField<bool>&
ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_spmd_sharding_propagation_to_output_;
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::_internal_mutable_allow_spmd_sharding_propagation_to_output() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.allow_spmd_sharding_propagation_to_output_;
}

// repeated bool param_requires_broadcast_via_collectives = 18;
inline int ExecutionOptions::_internal_param_requires_broadcast_via_collectives_size() const {
  return _internal_param_requires_broadcast_via_collectives().size();
}
inline int ExecutionOptions::param_requires_broadcast_via_collectives_size() const {
  return _internal_param_requires_broadcast_via_collectives_size();
}
inline void ExecutionOptions::clear_param_requires_broadcast_via_collectives() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.param_requires_broadcast_via_collectives_.Clear();
}
inline bool ExecutionOptions::param_requires_broadcast_via_collectives(int index) const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.param_requires_broadcast_via_collectives)
  return _internal_param_requires_broadcast_via_collectives().Get(index);
}
inline void ExecutionOptions::set_param_requires_broadcast_via_collectives(int index, bool value) {
  _internal_mutable_param_requires_broadcast_via_collectives()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.param_requires_broadcast_via_collectives)
}
inline void ExecutionOptions::add_param_requires_broadcast_via_collectives(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_param_requires_broadcast_via_collectives()->Add(value);
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.param_requires_broadcast_via_collectives)
}
inline const ::google::protobuf::RepeatedField<bool>& ExecutionOptions::param_requires_broadcast_via_collectives() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.param_requires_broadcast_via_collectives)
  return _internal_param_requires_broadcast_via_collectives();
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::mutable_param_requires_broadcast_via_collectives()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.param_requires_broadcast_via_collectives)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_param_requires_broadcast_via_collectives();
}
inline const ::google::protobuf::RepeatedField<bool>&
ExecutionOptions::_internal_param_requires_broadcast_via_collectives() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.param_requires_broadcast_via_collectives_;
}
inline ::google::protobuf::RepeatedField<bool>* ExecutionOptions::_internal_mutable_param_requires_broadcast_via_collectives() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.param_requires_broadcast_via_collectives_;
}

// bool allow_separate_sharding_programs = 19;
inline void ExecutionOptions::clear_allow_separate_sharding_programs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_separate_sharding_programs_ = false;
}
inline bool ExecutionOptions::allow_separate_sharding_programs() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_separate_sharding_programs)
  return _internal_allow_separate_sharding_programs();
}
inline void ExecutionOptions::set_allow_separate_sharding_programs(bool value) {
  _internal_set_allow_separate_sharding_programs(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_separate_sharding_programs)
}
inline bool ExecutionOptions::_internal_allow_separate_sharding_programs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_separate_sharding_programs_;
}
inline void ExecutionOptions::_internal_set_allow_separate_sharding_programs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_separate_sharding_programs_ = value;
}

// repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 20;
inline int ExecutionOptions::_internal_shardable_value_update_pairs_size() const {
  return _internal_shardable_value_update_pairs().size();
}
inline int ExecutionOptions::shardable_value_update_pairs_size() const {
  return _internal_shardable_value_update_pairs_size();
}
inline void ExecutionOptions::clear_shardable_value_update_pairs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shardable_value_update_pairs_.Clear();
}
inline ::xla::ShardableValueUpdatePairProto* ExecutionOptions::mutable_shardable_value_update_pairs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.shardable_value_update_pairs)
  return _internal_mutable_shardable_value_update_pairs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* ExecutionOptions::mutable_shardable_value_update_pairs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.shardable_value_update_pairs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_shardable_value_update_pairs();
}
inline const ::xla::ShardableValueUpdatePairProto& ExecutionOptions::shardable_value_update_pairs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.shardable_value_update_pairs)
  return _internal_shardable_value_update_pairs().Get(index);
}
inline ::xla::ShardableValueUpdatePairProto* ExecutionOptions::add_shardable_value_update_pairs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::ShardableValueUpdatePairProto* _add = _internal_mutable_shardable_value_update_pairs()->Add();
  // @@protoc_insertion_point(field_add:xla.ExecutionOptions.shardable_value_update_pairs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& ExecutionOptions::shardable_value_update_pairs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ExecutionOptions.shardable_value_update_pairs)
  return _internal_shardable_value_update_pairs();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>&
ExecutionOptions::_internal_shardable_value_update_pairs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shardable_value_update_pairs_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>*
ExecutionOptions::_internal_mutable_shardable_value_update_pairs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.shardable_value_update_pairs_;
}

// bytes fdo_profile = 21;
inline void ExecutionOptions::clear_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.ClearToEmpty();
}
inline const std::string& ExecutionOptions::fdo_profile() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.fdo_profile)
  return _internal_fdo_profile();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ExecutionOptions::set_fdo_profile(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.fdo_profile)
}
inline std::string* ExecutionOptions::mutable_fdo_profile() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fdo_profile();
  // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.fdo_profile)
  return _s;
}
inline const std::string& ExecutionOptions::_internal_fdo_profile() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fdo_profile_.Get();
}
inline void ExecutionOptions::_internal_set_fdo_profile(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.Set(value, GetArena());
}
inline std::string* ExecutionOptions::_internal_mutable_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.fdo_profile_.Mutable( GetArena());
}
inline std::string* ExecutionOptions::release_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ExecutionOptions.fdo_profile)
  return _impl_.fdo_profile_.Release();
}
inline void ExecutionOptions::set_allocated_fdo_profile(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fdo_profile_.IsDefault()) {
          _impl_.fdo_profile_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.fdo_profile)
}

// int64 device_memory_size = 22;
inline void ExecutionOptions::clear_device_memory_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_memory_size_ = ::int64_t{0};
}
inline ::int64_t ExecutionOptions::device_memory_size() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_memory_size)
  return _internal_device_memory_size();
}
inline void ExecutionOptions::set_device_memory_size(::int64_t value) {
  _internal_set_device_memory_size(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.device_memory_size)
}
inline ::int64_t ExecutionOptions::_internal_device_memory_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_memory_size_;
}
inline void ExecutionOptions::_internal_set_device_memory_size(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_memory_size_ = value;
}

// bool use_shardy_partitioner = 24;
inline void ExecutionOptions::clear_use_shardy_partitioner() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shardy_partitioner_ = false;
}
inline bool ExecutionOptions::use_shardy_partitioner() const {
  // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_shardy_partitioner)
  return _internal_use_shardy_partitioner();
}
inline void ExecutionOptions::set_use_shardy_partitioner(bool value) {
  _internal_set_use_shardy_partitioner(value);
  // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_shardy_partitioner)
}
inline bool ExecutionOptions::_internal_use_shardy_partitioner() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_shardy_partitioner_;
}
inline void ExecutionOptions::_internal_set_use_shardy_partitioner(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shardy_partitioner_ = value;
}

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

// HloModuleConfigProto_BoolList

// repeated bool vals = 1;
inline int HloModuleConfigProto_BoolList::_internal_vals_size() const {
  return _internal_vals().size();
}
inline int HloModuleConfigProto_BoolList::vals_size() const {
  return _internal_vals_size();
}
inline void HloModuleConfigProto_BoolList::clear_vals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vals_.Clear();
}
inline bool HloModuleConfigProto_BoolList::vals(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.BoolList.vals)
  return _internal_vals().Get(index);
}
inline void HloModuleConfigProto_BoolList::set_vals(int index, bool value) {
  _internal_mutable_vals()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.BoolList.vals)
}
inline void HloModuleConfigProto_BoolList::add_vals(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_vals()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.BoolList.vals)
}
inline const ::google::protobuf::RepeatedField<bool>& HloModuleConfigProto_BoolList::vals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.BoolList.vals)
  return _internal_vals();
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto_BoolList::mutable_vals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.BoolList.vals)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_vals();
}
inline const ::google::protobuf::RepeatedField<bool>&
HloModuleConfigProto_BoolList::_internal_vals() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.vals_;
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto_BoolList::_internal_mutable_vals() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.vals_;
}

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

// HloModuleConfigProto_Int64List

// repeated int64 vals = 1;
inline int HloModuleConfigProto_Int64List::_internal_vals_size() const {
  return _internal_vals().size();
}
inline int HloModuleConfigProto_Int64List::vals_size() const {
  return _internal_vals_size();
}
inline void HloModuleConfigProto_Int64List::clear_vals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vals_.Clear();
}
inline ::int64_t HloModuleConfigProto_Int64List::vals(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.Int64List.vals)
  return _internal_vals().Get(index);
}
inline void HloModuleConfigProto_Int64List::set_vals(int index, ::int64_t value) {
  _internal_mutable_vals()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.Int64List.vals)
}
inline void HloModuleConfigProto_Int64List::add_vals(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_vals()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.Int64List.vals)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& HloModuleConfigProto_Int64List::vals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.Int64List.vals)
  return _internal_vals();
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto_Int64List::mutable_vals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.Int64List.vals)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_vals();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
HloModuleConfigProto_Int64List::_internal_vals() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.vals_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto_Int64List::_internal_mutable_vals() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.vals_;
}

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

// HloModuleConfigProto_Int64ListList

// repeated .xla.HloModuleConfigProto.Int64List lists = 1;
inline int HloModuleConfigProto_Int64ListList::_internal_lists_size() const {
  return _internal_lists().size();
}
inline int HloModuleConfigProto_Int64ListList::lists_size() const {
  return _internal_lists_size();
}
inline void HloModuleConfigProto_Int64ListList::clear_lists() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lists_.Clear();
}
inline ::xla::HloModuleConfigProto_Int64List* HloModuleConfigProto_Int64ListList::mutable_lists(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.Int64ListList.lists)
  return _internal_mutable_lists()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>* HloModuleConfigProto_Int64ListList::mutable_lists()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.Int64ListList.lists)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_lists();
}
inline const ::xla::HloModuleConfigProto_Int64List& HloModuleConfigProto_Int64ListList::lists(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.Int64ListList.lists)
  return _internal_lists().Get(index);
}
inline ::xla::HloModuleConfigProto_Int64List* HloModuleConfigProto_Int64ListList::add_lists() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::HloModuleConfigProto_Int64List* _add = _internal_mutable_lists()->Add();
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.Int64ListList.lists)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>& HloModuleConfigProto_Int64ListList::lists() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.Int64ListList.lists)
  return _internal_lists();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>&
HloModuleConfigProto_Int64ListList::_internal_lists() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lists_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64List>*
HloModuleConfigProto_Int64ListList::_internal_mutable_lists() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.lists_;
}

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

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

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

// HloModuleConfigProto

// .xla.ProgramShapeProto entry_computation_layout = 1;
inline bool HloModuleConfigProto::has_entry_computation_layout() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entry_computation_layout_ != nullptr);
  return value;
}
inline const ::xla::ProgramShapeProto& HloModuleConfigProto::_internal_entry_computation_layout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::ProgramShapeProto* p = _impl_.entry_computation_layout_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ProgramShapeProto&>(::xla::_ProgramShapeProto_default_instance_);
}
inline const ::xla::ProgramShapeProto& HloModuleConfigProto::entry_computation_layout() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.entry_computation_layout)
  return _internal_entry_computation_layout();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_entry_computation_layout(::xla::ProgramShapeProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_computation_layout_);
  }
  _impl_.entry_computation_layout_ = reinterpret_cast<::xla::ProgramShapeProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.entry_computation_layout)
}
inline ::xla::ProgramShapeProto* HloModuleConfigProto::release_entry_computation_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ProgramShapeProto* released = _impl_.entry_computation_layout_;
  _impl_.entry_computation_layout_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::ProgramShapeProto* HloModuleConfigProto::unsafe_arena_release_entry_computation_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.entry_computation_layout)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ProgramShapeProto* temp = _impl_.entry_computation_layout_;
  _impl_.entry_computation_layout_ = nullptr;
  return temp;
}
inline ::xla::ProgramShapeProto* HloModuleConfigProto::_internal_mutable_entry_computation_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.entry_computation_layout_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::ProgramShapeProto>(GetArena());
    _impl_.entry_computation_layout_ = reinterpret_cast<::xla::ProgramShapeProto*>(p);
  }
  return _impl_.entry_computation_layout_;
}
inline ::xla::ProgramShapeProto* HloModuleConfigProto::mutable_entry_computation_layout() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::ProgramShapeProto* _msg = _internal_mutable_entry_computation_layout();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.entry_computation_layout)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_entry_computation_layout(::xla::ProgramShapeProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_computation_layout_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.entry_computation_layout_ = reinterpret_cast<::xla::ProgramShapeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.entry_computation_layout)
}

// uint64 seed = 2;
inline void HloModuleConfigProto::clear_seed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_ = ::uint64_t{0u};
}
inline ::uint64_t HloModuleConfigProto::seed() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.seed)
  return _internal_seed();
}
inline void HloModuleConfigProto::set_seed(::uint64_t value) {
  _internal_set_seed(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.seed)
}
inline ::uint64_t HloModuleConfigProto::_internal_seed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seed_;
}
inline void HloModuleConfigProto::_internal_set_seed(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_ = value;
}

// int32 launch_id = 3;
inline void HloModuleConfigProto::clear_launch_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.launch_id_ = 0;
}
inline ::int32_t HloModuleConfigProto::launch_id() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.launch_id)
  return _internal_launch_id();
}
inline void HloModuleConfigProto::set_launch_id(::int32_t value) {
  _internal_set_launch_id(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.launch_id)
}
inline ::int32_t HloModuleConfigProto::_internal_launch_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.launch_id_;
}
inline void HloModuleConfigProto::_internal_set_launch_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.launch_id_ = value;
}

// int64 replica_count = 4;
inline void HloModuleConfigProto::clear_replica_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.replica_count_ = ::int64_t{0};
}
inline ::int64_t HloModuleConfigProto::replica_count() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.replica_count)
  return _internal_replica_count();
}
inline void HloModuleConfigProto::set_replica_count(::int64_t value) {
  _internal_set_replica_count(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.replica_count)
}
inline ::int64_t HloModuleConfigProto::_internal_replica_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.replica_count_;
}
inline void HloModuleConfigProto::_internal_set_replica_count(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.replica_count_ = value;
}

// int64 num_partitions = 5;
inline void HloModuleConfigProto::clear_num_partitions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_partitions_ = ::int64_t{0};
}
inline ::int64_t HloModuleConfigProto::num_partitions() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.num_partitions)
  return _internal_num_partitions();
}
inline void HloModuleConfigProto::set_num_partitions(::int64_t value) {
  _internal_set_num_partitions(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.num_partitions)
}
inline ::int64_t HloModuleConfigProto::_internal_num_partitions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_partitions_;
}
inline void HloModuleConfigProto::_internal_set_num_partitions(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_partitions_ = value;
}

// repeated bool param_requires_broadcast_via_collectives = 6;
inline int HloModuleConfigProto::_internal_param_requires_broadcast_via_collectives_size() const {
  return _internal_param_requires_broadcast_via_collectives().size();
}
inline int HloModuleConfigProto::param_requires_broadcast_via_collectives_size() const {
  return _internal_param_requires_broadcast_via_collectives_size();
}
inline void HloModuleConfigProto::clear_param_requires_broadcast_via_collectives() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.param_requires_broadcast_via_collectives_.Clear();
}
inline bool HloModuleConfigProto::param_requires_broadcast_via_collectives(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives)
  return _internal_param_requires_broadcast_via_collectives().Get(index);
}
inline void HloModuleConfigProto::set_param_requires_broadcast_via_collectives(int index, bool value) {
  _internal_mutable_param_requires_broadcast_via_collectives()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives)
}
inline void HloModuleConfigProto::add_param_requires_broadcast_via_collectives(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_param_requires_broadcast_via_collectives()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives)
}
inline const ::google::protobuf::RepeatedField<bool>& HloModuleConfigProto::param_requires_broadcast_via_collectives() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives)
  return _internal_param_requires_broadcast_via_collectives();
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::mutable_param_requires_broadcast_via_collectives()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_param_requires_broadcast_via_collectives();
}
inline const ::google::protobuf::RepeatedField<bool>&
HloModuleConfigProto::_internal_param_requires_broadcast_via_collectives() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.param_requires_broadcast_via_collectives_;
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::_internal_mutable_param_requires_broadcast_via_collectives() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.param_requires_broadcast_via_collectives_;
}

// bool use_spmd_partitioning = 7;
inline void HloModuleConfigProto::clear_use_spmd_partitioning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_spmd_partitioning_ = false;
}
inline bool HloModuleConfigProto::use_spmd_partitioning() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_spmd_partitioning)
  return _internal_use_spmd_partitioning();
}
inline void HloModuleConfigProto::set_use_spmd_partitioning(bool value) {
  _internal_set_use_spmd_partitioning(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_spmd_partitioning)
}
inline bool HloModuleConfigProto::_internal_use_spmd_partitioning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_spmd_partitioning_;
}
inline void HloModuleConfigProto::_internal_set_use_spmd_partitioning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_spmd_partitioning_ = value;
}

// bool use_auto_spmd_partitioning = 8;
inline void HloModuleConfigProto::clear_use_auto_spmd_partitioning() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_auto_spmd_partitioning_ = false;
}
inline bool HloModuleConfigProto::use_auto_spmd_partitioning() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_auto_spmd_partitioning)
  return _internal_use_auto_spmd_partitioning();
}
inline void HloModuleConfigProto::set_use_auto_spmd_partitioning(bool value) {
  _internal_set_use_auto_spmd_partitioning(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_auto_spmd_partitioning)
}
inline bool HloModuleConfigProto::_internal_use_auto_spmd_partitioning() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_auto_spmd_partitioning_;
}
inline void HloModuleConfigProto::_internal_set_use_auto_spmd_partitioning(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_auto_spmd_partitioning_ = value;
}

// repeated int64 auto_spmd_partitioning_mesh_shape = 9;
inline int HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_shape_size() const {
  return _internal_auto_spmd_partitioning_mesh_shape().size();
}
inline int HloModuleConfigProto::auto_spmd_partitioning_mesh_shape_size() const {
  return _internal_auto_spmd_partitioning_mesh_shape_size();
}
inline void HloModuleConfigProto::clear_auto_spmd_partitioning_mesh_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_spmd_partitioning_mesh_shape_.Clear();
}
inline ::int64_t HloModuleConfigProto::auto_spmd_partitioning_mesh_shape(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape)
  return _internal_auto_spmd_partitioning_mesh_shape().Get(index);
}
inline void HloModuleConfigProto::set_auto_spmd_partitioning_mesh_shape(int index, ::int64_t value) {
  _internal_mutable_auto_spmd_partitioning_mesh_shape()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape)
}
inline void HloModuleConfigProto::add_auto_spmd_partitioning_mesh_shape(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_auto_spmd_partitioning_mesh_shape()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& HloModuleConfigProto::auto_spmd_partitioning_mesh_shape() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape)
  return _internal_auto_spmd_partitioning_mesh_shape();
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto::mutable_auto_spmd_partitioning_mesh_shape()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_auto_spmd_partitioning_mesh_shape();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_shape() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auto_spmd_partitioning_mesh_shape_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto::_internal_mutable_auto_spmd_partitioning_mesh_shape() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.auto_spmd_partitioning_mesh_shape_;
}

// repeated int64 auto_spmd_partitioning_mesh_ids = 10;
inline int HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_ids_size() const {
  return _internal_auto_spmd_partitioning_mesh_ids().size();
}
inline int HloModuleConfigProto::auto_spmd_partitioning_mesh_ids_size() const {
  return _internal_auto_spmd_partitioning_mesh_ids_size();
}
inline void HloModuleConfigProto::clear_auto_spmd_partitioning_mesh_ids() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_spmd_partitioning_mesh_ids_.Clear();
}
inline ::int64_t HloModuleConfigProto::auto_spmd_partitioning_mesh_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids)
  return _internal_auto_spmd_partitioning_mesh_ids().Get(index);
}
inline void HloModuleConfigProto::set_auto_spmd_partitioning_mesh_ids(int index, ::int64_t value) {
  _internal_mutable_auto_spmd_partitioning_mesh_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids)
}
inline void HloModuleConfigProto::add_auto_spmd_partitioning_mesh_ids(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_auto_spmd_partitioning_mesh_ids()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& HloModuleConfigProto::auto_spmd_partitioning_mesh_ids() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids)
  return _internal_auto_spmd_partitioning_mesh_ids();
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto::mutable_auto_spmd_partitioning_mesh_ids()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_auto_spmd_partitioning_mesh_ids();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_ids() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auto_spmd_partitioning_mesh_ids_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* HloModuleConfigProto::_internal_mutable_auto_spmd_partitioning_mesh_ids() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.auto_spmd_partitioning_mesh_ids_;
}

// float exec_time_optimization_effort = 36 [deprecated = true];
inline void HloModuleConfigProto::clear_exec_time_optimization_effort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_time_optimization_effort_ = 0;
}
inline float HloModuleConfigProto::exec_time_optimization_effort() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.exec_time_optimization_effort)
  return _internal_exec_time_optimization_effort();
}
inline void HloModuleConfigProto::set_exec_time_optimization_effort(float value) {
  _internal_set_exec_time_optimization_effort(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.exec_time_optimization_effort)
}
inline float HloModuleConfigProto::_internal_exec_time_optimization_effort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exec_time_optimization_effort_;
}
inline void HloModuleConfigProto::_internal_set_exec_time_optimization_effort(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_time_optimization_effort_ = value;
}

// float memory_fitting_effort = 37 [deprecated = true];
inline void HloModuleConfigProto::clear_memory_fitting_effort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_effort_ = 0;
}
inline float HloModuleConfigProto::memory_fitting_effort() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.memory_fitting_effort)
  return _internal_memory_fitting_effort();
}
inline void HloModuleConfigProto::set_memory_fitting_effort(float value) {
  _internal_set_memory_fitting_effort(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.memory_fitting_effort)
}
inline float HloModuleConfigProto::_internal_memory_fitting_effort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.memory_fitting_effort_;
}
inline void HloModuleConfigProto::_internal_set_memory_fitting_effort(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_effort_ = value;
}

// .xla.ExecutionOptions.EffortLevel optimization_level = 39;
inline void HloModuleConfigProto::clear_optimization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimization_level_ = 0;
}
inline ::xla::ExecutionOptions_EffortLevel HloModuleConfigProto::optimization_level() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.optimization_level)
  return _internal_optimization_level();
}
inline void HloModuleConfigProto::set_optimization_level(::xla::ExecutionOptions_EffortLevel value) {
  _internal_set_optimization_level(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.optimization_level)
}
inline ::xla::ExecutionOptions_EffortLevel HloModuleConfigProto::_internal_optimization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::ExecutionOptions_EffortLevel>(_impl_.optimization_level_);
}
inline void HloModuleConfigProto::_internal_set_optimization_level(::xla::ExecutionOptions_EffortLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimization_level_ = value;
}

// .xla.ExecutionOptions.EffortLevel memory_fitting_level = 40;
inline void HloModuleConfigProto::clear_memory_fitting_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_level_ = 0;
}
inline ::xla::ExecutionOptions_EffortLevel HloModuleConfigProto::memory_fitting_level() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.memory_fitting_level)
  return _internal_memory_fitting_level();
}
inline void HloModuleConfigProto::set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value) {
  _internal_set_memory_fitting_level(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.memory_fitting_level)
}
inline ::xla::ExecutionOptions_EffortLevel HloModuleConfigProto::_internal_memory_fitting_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::ExecutionOptions_EffortLevel>(_impl_.memory_fitting_level_);
}
inline void HloModuleConfigProto::_internal_set_memory_fitting_level(::xla::ExecutionOptions_EffortLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_fitting_level_ = value;
}

// bool deduplicate_hlo = 11;
inline void HloModuleConfigProto::clear_deduplicate_hlo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.deduplicate_hlo_ = false;
}
inline bool HloModuleConfigProto::deduplicate_hlo() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.deduplicate_hlo)
  return _internal_deduplicate_hlo();
}
inline void HloModuleConfigProto::set_deduplicate_hlo(bool value) {
  _internal_set_deduplicate_hlo(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.deduplicate_hlo)
}
inline bool HloModuleConfigProto::_internal_deduplicate_hlo() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.deduplicate_hlo_;
}
inline void HloModuleConfigProto::_internal_set_deduplicate_hlo(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.deduplicate_hlo_ = value;
}

// int64 intra_op_parallelism_threads = 12;
inline void HloModuleConfigProto::clear_intra_op_parallelism_threads() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.intra_op_parallelism_threads_ = ::int64_t{0};
}
inline ::int64_t HloModuleConfigProto::intra_op_parallelism_threads() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.intra_op_parallelism_threads)
  return _internal_intra_op_parallelism_threads();
}
inline void HloModuleConfigProto::set_intra_op_parallelism_threads(::int64_t value) {
  _internal_set_intra_op_parallelism_threads(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.intra_op_parallelism_threads)
}
inline ::int64_t HloModuleConfigProto::_internal_intra_op_parallelism_threads() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.intra_op_parallelism_threads_;
}
inline void HloModuleConfigProto::_internal_set_intra_op_parallelism_threads(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.intra_op_parallelism_threads_ = value;
}

// string device_type = 13;
inline void HloModuleConfigProto::clear_device_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_type_.ClearToEmpty();
}
inline const std::string& HloModuleConfigProto::device_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.device_type)
  return _internal_device_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void HloModuleConfigProto::set_device_type(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.device_type)
}
inline std::string* HloModuleConfigProto::mutable_device_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_device_type();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.device_type)
  return _s;
}
inline const std::string& HloModuleConfigProto::_internal_device_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_type_.Get();
}
inline void HloModuleConfigProto::_internal_set_device_type(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_type_.Set(value, GetArena());
}
inline std::string* HloModuleConfigProto::_internal_mutable_device_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.device_type_.Mutable( GetArena());
}
inline std::string* HloModuleConfigProto::release_device_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.device_type)
  return _impl_.device_type_.Release();
}
inline void HloModuleConfigProto::set_allocated_device_type(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.device_type_.IsDefault()) {
          _impl_.device_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.device_type)
}

// .xla.DebugOptions debug_options = 14;
inline bool HloModuleConfigProto::has_debug_options() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.debug_options_ != nullptr);
  return value;
}
inline void HloModuleConfigProto::clear_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.debug_options_ != nullptr) _impl_.debug_options_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::xla::DebugOptions& HloModuleConfigProto::_internal_debug_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::DebugOptions* p = _impl_.debug_options_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DebugOptions&>(::xla::_DebugOptions_default_instance_);
}
inline const ::xla::DebugOptions& HloModuleConfigProto::debug_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.debug_options)
  return _internal_debug_options();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_debug_options(::xla::DebugOptions* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.debug_options_);
  }
  _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.debug_options)
}
inline ::xla::DebugOptions* HloModuleConfigProto::release_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::DebugOptions* released = _impl_.debug_options_;
  _impl_.debug_options_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::DebugOptions* HloModuleConfigProto::unsafe_arena_release_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.debug_options)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::DebugOptions* temp = _impl_.debug_options_;
  _impl_.debug_options_ = nullptr;
  return temp;
}
inline ::xla::DebugOptions* HloModuleConfigProto::_internal_mutable_debug_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.debug_options_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::DebugOptions>(GetArena());
    _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(p);
  }
  return _impl_.debug_options_;
}
inline ::xla::DebugOptions* HloModuleConfigProto::mutable_debug_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::xla::DebugOptions* _msg = _internal_mutable_debug_options();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.debug_options)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_debug_options(::xla::DebugOptions* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.debug_options_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.debug_options_ = reinterpret_cast<::xla::DebugOptions*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.debug_options)
}

// .xla.DeviceAssignmentProto static_device_assignment = 15;
inline bool HloModuleConfigProto::has_static_device_assignment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.static_device_assignment_ != nullptr);
  return value;
}
inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::_internal_static_device_assignment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::DeviceAssignmentProto* p = _impl_.static_device_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DeviceAssignmentProto&>(::xla::_DeviceAssignmentProto_default_instance_);
}
inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::static_device_assignment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.static_device_assignment)
  return _internal_static_device_assignment();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.static_device_assignment_);
  }
  _impl_.static_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.static_device_assignment)
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::release_static_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::xla::DeviceAssignmentProto* released = _impl_.static_device_assignment_;
  _impl_.static_device_assignment_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::unsafe_arena_release_static_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.static_device_assignment)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::xla::DeviceAssignmentProto* temp = _impl_.static_device_assignment_;
  _impl_.static_device_assignment_ = nullptr;
  return temp;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::_internal_mutable_static_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.static_device_assignment_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::DeviceAssignmentProto>(GetArena());
    _impl_.static_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(p);
  }
  return _impl_.static_device_assignment_;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::mutable_static_device_assignment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000004u;
  ::xla::DeviceAssignmentProto* _msg = _internal_mutable_static_device_assignment();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.static_device_assignment)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.static_device_assignment_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.static_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.static_device_assignment)
}

// .xla.DeviceAssignmentProto pre_simulation_device_assignment = 35;
inline bool HloModuleConfigProto::has_pre_simulation_device_assignment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pre_simulation_device_assignment_ != nullptr);
  return value;
}
inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::_internal_pre_simulation_device_assignment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::DeviceAssignmentProto* p = _impl_.pre_simulation_device_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DeviceAssignmentProto&>(::xla::_DeviceAssignmentProto_default_instance_);
}
inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::pre_simulation_device_assignment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.pre_simulation_device_assignment)
  return _internal_pre_simulation_device_assignment();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pre_simulation_device_assignment_);
  }
  _impl_.pre_simulation_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.pre_simulation_device_assignment)
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::release_pre_simulation_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::xla::DeviceAssignmentProto* released = _impl_.pre_simulation_device_assignment_;
  _impl_.pre_simulation_device_assignment_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::unsafe_arena_release_pre_simulation_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.pre_simulation_device_assignment)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::xla::DeviceAssignmentProto* temp = _impl_.pre_simulation_device_assignment_;
  _impl_.pre_simulation_device_assignment_ = nullptr;
  return temp;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::_internal_mutable_pre_simulation_device_assignment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.pre_simulation_device_assignment_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::DeviceAssignmentProto>(GetArena());
    _impl_.pre_simulation_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(p);
  }
  return _impl_.pre_simulation_device_assignment_;
}
inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::mutable_pre_simulation_device_assignment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000008u;
  ::xla::DeviceAssignmentProto* _msg = _internal_mutable_pre_simulation_device_assignment();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.pre_simulation_device_assignment)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pre_simulation_device_assignment_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.pre_simulation_device_assignment_ = reinterpret_cast<::xla::DeviceAssignmentProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.pre_simulation_device_assignment)
}

// bool allow_separate_sharding_programs = 30;
inline void HloModuleConfigProto::clear_allow_separate_sharding_programs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_separate_sharding_programs_ = false;
}
inline bool HloModuleConfigProto::allow_separate_sharding_programs() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_separate_sharding_programs)
  return _internal_allow_separate_sharding_programs();
}
inline void HloModuleConfigProto::set_allow_separate_sharding_programs(bool value) {
  _internal_set_allow_separate_sharding_programs(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_separate_sharding_programs)
}
inline bool HloModuleConfigProto::_internal_allow_separate_sharding_programs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_separate_sharding_programs_;
}
inline void HloModuleConfigProto::_internal_set_allow_separate_sharding_programs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_separate_sharding_programs_ = value;
}

// repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 16;
inline int HloModuleConfigProto::_internal_shardable_value_update_pairs_size() const {
  return _internal_shardable_value_update_pairs().size();
}
inline int HloModuleConfigProto::shardable_value_update_pairs_size() const {
  return _internal_shardable_value_update_pairs_size();
}
inline void HloModuleConfigProto::clear_shardable_value_update_pairs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shardable_value_update_pairs_.Clear();
}
inline ::xla::ShardableValueUpdatePairProto* HloModuleConfigProto::mutable_shardable_value_update_pairs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.shardable_value_update_pairs)
  return _internal_mutable_shardable_value_update_pairs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>* HloModuleConfigProto::mutable_shardable_value_update_pairs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.shardable_value_update_pairs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_shardable_value_update_pairs();
}
inline const ::xla::ShardableValueUpdatePairProto& HloModuleConfigProto::shardable_value_update_pairs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.shardable_value_update_pairs)
  return _internal_shardable_value_update_pairs().Get(index);
}
inline ::xla::ShardableValueUpdatePairProto* HloModuleConfigProto::add_shardable_value_update_pairs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::ShardableValueUpdatePairProto* _add = _internal_mutable_shardable_value_update_pairs()->Add();
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.shardable_value_update_pairs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>& HloModuleConfigProto::shardable_value_update_pairs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.shardable_value_update_pairs)
  return _internal_shardable_value_update_pairs();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>&
HloModuleConfigProto::_internal_shardable_value_update_pairs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shardable_value_update_pairs_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::ShardableValueUpdatePairProto>*
HloModuleConfigProto::_internal_mutable_shardable_value_update_pairs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.shardable_value_update_pairs_;
}

// bool alias_passthrough_params = 17;
inline void HloModuleConfigProto::clear_alias_passthrough_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alias_passthrough_params_ = false;
}
inline bool HloModuleConfigProto::alias_passthrough_params() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.alias_passthrough_params)
  return _internal_alias_passthrough_params();
}
inline void HloModuleConfigProto::set_alias_passthrough_params(bool value) {
  _internal_set_alias_passthrough_params(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.alias_passthrough_params)
}
inline bool HloModuleConfigProto::_internal_alias_passthrough_params() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alias_passthrough_params_;
}
inline void HloModuleConfigProto::_internal_set_alias_passthrough_params(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alias_passthrough_params_ = value;
}

// bool content_aware_computation_sorting = 18;
inline void HloModuleConfigProto::clear_content_aware_computation_sorting() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.content_aware_computation_sorting_ = false;
}
inline bool HloModuleConfigProto::content_aware_computation_sorting() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.content_aware_computation_sorting)
  return _internal_content_aware_computation_sorting();
}
inline void HloModuleConfigProto::set_content_aware_computation_sorting(bool value) {
  _internal_set_content_aware_computation_sorting(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.content_aware_computation_sorting)
}
inline bool HloModuleConfigProto::_internal_content_aware_computation_sorting() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.content_aware_computation_sorting_;
}
inline void HloModuleConfigProto::_internal_set_content_aware_computation_sorting(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.content_aware_computation_sorting_ = value;
}

// .xla.HloModuleConfigProto.FusionConfigCollection fusion_config_collection = 19;
inline void HloModuleConfigProto::clear_fusion_config_collection() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fusion_config_collection_ = 0;
}
inline ::xla::HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto::fusion_config_collection() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fusion_config_collection)
  return _internal_fusion_config_collection();
}
inline void HloModuleConfigProto::set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value) {
  _internal_set_fusion_config_collection(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.fusion_config_collection)
}
inline ::xla::HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto::_internal_fusion_config_collection() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::HloModuleConfigProto_FusionConfigCollection>(_impl_.fusion_config_collection_);
}
inline void HloModuleConfigProto::_internal_set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fusion_config_collection_ = value;
}

// repeated .xla.HloModuleConfigProto.BoolList fusion_config = 20;
inline int HloModuleConfigProto::_internal_fusion_config_size() const {
  return _internal_fusion_config().size();
}
inline int HloModuleConfigProto::fusion_config_size() const {
  return _internal_fusion_config_size();
}
inline void HloModuleConfigProto::clear_fusion_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fusion_config_.Clear();
}
inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::mutable_fusion_config(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.fusion_config)
  return _internal_mutable_fusion_config()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* HloModuleConfigProto::mutable_fusion_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.fusion_config)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_fusion_config();
}
inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::fusion_config(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fusion_config)
  return _internal_fusion_config().Get(index);
}
inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::add_fusion_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::HloModuleConfigProto_BoolList* _add = _internal_mutable_fusion_config()->Add();
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.fusion_config)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& HloModuleConfigProto::fusion_config() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.fusion_config)
  return _internal_fusion_config();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>&
HloModuleConfigProto::_internal_fusion_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fusion_config_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>*
HloModuleConfigProto::_internal_mutable_fusion_config() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.fusion_config_;
}

// map<string, .xla.HloModuleConfigProto.Int64List> dot_config = 21;
inline int HloModuleConfigProto::_internal_dot_config_size() const {
  return _internal_dot_config().size();
}
inline int HloModuleConfigProto::dot_config_size() const {
  return _internal_dot_config_size();
}
inline void HloModuleConfigProto::clear_dot_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dot_config_.Clear();
}
inline const ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>& HloModuleConfigProto::_internal_dot_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dot_config_.GetMap();
}
inline const ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>& HloModuleConfigProto::dot_config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:xla.HloModuleConfigProto.dot_config)
  return _internal_dot_config();
}
inline ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>* HloModuleConfigProto::_internal_mutable_dot_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.dot_config_.MutableMap();
}
inline ::google::protobuf::Map<std::string, ::xla::HloModuleConfigProto_Int64List>* HloModuleConfigProto::mutable_dot_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:xla.HloModuleConfigProto.dot_config)
  return _internal_mutable_dot_config();
}

// repeated .xla.HloModuleConfigProto.Int64ListList layout_config = 22;
inline int HloModuleConfigProto::_internal_layout_config_size() const {
  return _internal_layout_config().size();
}
inline int HloModuleConfigProto::layout_config_size() const {
  return _internal_layout_config_size();
}
inline void HloModuleConfigProto::clear_layout_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.layout_config_.Clear();
}
inline ::xla::HloModuleConfigProto_Int64ListList* HloModuleConfigProto::mutable_layout_config(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.layout_config)
  return _internal_mutable_layout_config()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>* HloModuleConfigProto::mutable_layout_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.layout_config)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_layout_config();
}
inline const ::xla::HloModuleConfigProto_Int64ListList& HloModuleConfigProto::layout_config(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.layout_config)
  return _internal_layout_config().Get(index);
}
inline ::xla::HloModuleConfigProto_Int64ListList* HloModuleConfigProto::add_layout_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::HloModuleConfigProto_Int64ListList* _add = _internal_mutable_layout_config()->Add();
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.layout_config)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>& HloModuleConfigProto::layout_config() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.layout_config)
  return _internal_layout_config();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>&
HloModuleConfigProto::_internal_layout_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.layout_config_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_Int64ListList>*
HloModuleConfigProto::_internal_mutable_layout_config() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.layout_config_;
}

// repeated uint64 memory_space_assignment_config = 23;
inline int HloModuleConfigProto::_internal_memory_space_assignment_config_size() const {
  return _internal_memory_space_assignment_config().size();
}
inline int HloModuleConfigProto::memory_space_assignment_config_size() const {
  return _internal_memory_space_assignment_config_size();
}
inline void HloModuleConfigProto::clear_memory_space_assignment_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_space_assignment_config_.Clear();
}
inline ::uint64_t HloModuleConfigProto::memory_space_assignment_config(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.memory_space_assignment_config)
  return _internal_memory_space_assignment_config().Get(index);
}
inline void HloModuleConfigProto::set_memory_space_assignment_config(int index, ::uint64_t value) {
  _internal_mutable_memory_space_assignment_config()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.memory_space_assignment_config)
}
inline void HloModuleConfigProto::add_memory_space_assignment_config(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_memory_space_assignment_config()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.memory_space_assignment_config)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& HloModuleConfigProto::memory_space_assignment_config() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.memory_space_assignment_config)
  return _internal_memory_space_assignment_config();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* HloModuleConfigProto::mutable_memory_space_assignment_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.memory_space_assignment_config)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_memory_space_assignment_config();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>&
HloModuleConfigProto::_internal_memory_space_assignment_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.memory_space_assignment_config_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* HloModuleConfigProto::_internal_mutable_memory_space_assignment_config() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.memory_space_assignment_config_;
}

// repeated .xla.HloModuleConfigProto.BoolList phase_ordering_config = 24;
inline int HloModuleConfigProto::_internal_phase_ordering_config_size() const {
  return _internal_phase_ordering_config().size();
}
inline int HloModuleConfigProto::phase_ordering_config_size() const {
  return _internal_phase_ordering_config_size();
}
inline void HloModuleConfigProto::clear_phase_ordering_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.phase_ordering_config_.Clear();
}
inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::mutable_phase_ordering_config(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.phase_ordering_config)
  return _internal_mutable_phase_ordering_config()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>* HloModuleConfigProto::mutable_phase_ordering_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.phase_ordering_config)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_phase_ordering_config();
}
inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::phase_ordering_config(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.phase_ordering_config)
  return _internal_phase_ordering_config().Get(index);
}
inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::add_phase_ordering_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::HloModuleConfigProto_BoolList* _add = _internal_mutable_phase_ordering_config()->Add();
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.phase_ordering_config)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>& HloModuleConfigProto::phase_ordering_config() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.phase_ordering_config)
  return _internal_phase_ordering_config();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>&
HloModuleConfigProto::_internal_phase_ordering_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.phase_ordering_config_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::HloModuleConfigProto_BoolList>*
HloModuleConfigProto::_internal_mutable_phase_ordering_config() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.phase_ordering_config_;
}

// int32 phase_index = 25;
inline void HloModuleConfigProto::clear_phase_index() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.phase_index_ = 0;
}
inline ::int32_t HloModuleConfigProto::phase_index() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.phase_index)
  return _internal_phase_index();
}
inline void HloModuleConfigProto::set_phase_index(::int32_t value) {
  _internal_set_phase_index(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.phase_index)
}
inline ::int32_t HloModuleConfigProto::_internal_phase_index() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.phase_index_;
}
inline void HloModuleConfigProto::_internal_set_phase_index(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.phase_index_ = value;
}

// repeated bool allow_spmd_sharding_propagation_to_parameters = 33;
inline int HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_parameters_size() const {
  return _internal_allow_spmd_sharding_propagation_to_parameters().size();
}
inline int HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters_size() const {
  return _internal_allow_spmd_sharding_propagation_to_parameters_size();
}
inline void HloModuleConfigProto::clear_allow_spmd_sharding_propagation_to_parameters() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_spmd_sharding_propagation_to_parameters_.Clear();
}
inline bool HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters)
  return _internal_allow_spmd_sharding_propagation_to_parameters().Get(index);
}
inline void HloModuleConfigProto::set_allow_spmd_sharding_propagation_to_parameters(int index, bool value) {
  _internal_mutable_allow_spmd_sharding_propagation_to_parameters()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters)
}
inline void HloModuleConfigProto::add_allow_spmd_sharding_propagation_to_parameters(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_allow_spmd_sharding_propagation_to_parameters()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters)
}
inline const ::google::protobuf::RepeatedField<bool>& HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters)
  return _internal_allow_spmd_sharding_propagation_to_parameters();
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::mutable_allow_spmd_sharding_propagation_to_parameters()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_allow_spmd_sharding_propagation_to_parameters();
}
inline const ::google::protobuf::RepeatedField<bool>&
HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_parameters() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_spmd_sharding_propagation_to_parameters_;
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::_internal_mutable_allow_spmd_sharding_propagation_to_parameters() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.allow_spmd_sharding_propagation_to_parameters_;
}

// repeated bool allow_spmd_sharding_propagation_to_output = 27;
inline int HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_output_size() const {
  return _internal_allow_spmd_sharding_propagation_to_output().size();
}
inline int HloModuleConfigProto::allow_spmd_sharding_propagation_to_output_size() const {
  return _internal_allow_spmd_sharding_propagation_to_output_size();
}
inline void HloModuleConfigProto::clear_allow_spmd_sharding_propagation_to_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_spmd_sharding_propagation_to_output_.Clear();
}
inline bool HloModuleConfigProto::allow_spmd_sharding_propagation_to_output(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output)
  return _internal_allow_spmd_sharding_propagation_to_output().Get(index);
}
inline void HloModuleConfigProto::set_allow_spmd_sharding_propagation_to_output(int index, bool value) {
  _internal_mutable_allow_spmd_sharding_propagation_to_output()->Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output)
}
inline void HloModuleConfigProto::add_allow_spmd_sharding_propagation_to_output(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_allow_spmd_sharding_propagation_to_output()->Add(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output)
}
inline const ::google::protobuf::RepeatedField<bool>& HloModuleConfigProto::allow_spmd_sharding_propagation_to_output() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output)
  return _internal_allow_spmd_sharding_propagation_to_output();
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::mutable_allow_spmd_sharding_propagation_to_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_allow_spmd_sharding_propagation_to_output();
}
inline const ::google::protobuf::RepeatedField<bool>&
HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_spmd_sharding_propagation_to_output_;
}
inline ::google::protobuf::RepeatedField<bool>* HloModuleConfigProto::_internal_mutable_allow_spmd_sharding_propagation_to_output() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.allow_spmd_sharding_propagation_to_output_;
}

// map<string, int64> analysis_allowance_map = 28;
inline int HloModuleConfigProto::_internal_analysis_allowance_map_size() const {
  return _internal_analysis_allowance_map().size();
}
inline int HloModuleConfigProto::analysis_allowance_map_size() const {
  return _internal_analysis_allowance_map_size();
}
inline void HloModuleConfigProto::clear_analysis_allowance_map() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.analysis_allowance_map_.Clear();
}
inline const ::google::protobuf::Map<std::string, ::int64_t>& HloModuleConfigProto::_internal_analysis_allowance_map() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.analysis_allowance_map_.GetMap();
}
inline const ::google::protobuf::Map<std::string, ::int64_t>& HloModuleConfigProto::analysis_allowance_map() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:xla.HloModuleConfigProto.analysis_allowance_map)
  return _internal_analysis_allowance_map();
}
inline ::google::protobuf::Map<std::string, ::int64_t>* HloModuleConfigProto::_internal_mutable_analysis_allowance_map() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.analysis_allowance_map_.MutableMap();
}
inline ::google::protobuf::Map<std::string, ::int64_t>* HloModuleConfigProto::mutable_analysis_allowance_map() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:xla.HloModuleConfigProto.analysis_allowance_map)
  return _internal_mutable_analysis_allowance_map();
}

// .xla.PrecisionConfig.Precision matrix_unit_operand_precision = 29;
inline void HloModuleConfigProto::clear_matrix_unit_operand_precision() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.matrix_unit_operand_precision_ = 0;
}
inline ::xla::PrecisionConfig_Precision HloModuleConfigProto::matrix_unit_operand_precision() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.matrix_unit_operand_precision)
  return _internal_matrix_unit_operand_precision();
}
inline void HloModuleConfigProto::set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value) {
  _internal_set_matrix_unit_operand_precision(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.matrix_unit_operand_precision)
}
inline ::xla::PrecisionConfig_Precision HloModuleConfigProto::_internal_matrix_unit_operand_precision() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::xla::PrecisionConfig_Precision>(_impl_.matrix_unit_operand_precision_);
}
inline void HloModuleConfigProto::_internal_set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.matrix_unit_operand_precision_ = value;
}

// bytes fdo_profile = 31;
inline void HloModuleConfigProto::clear_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.ClearToEmpty();
}
inline const std::string& HloModuleConfigProto::fdo_profile() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fdo_profile)
  return _internal_fdo_profile();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void HloModuleConfigProto::set_fdo_profile(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.fdo_profile)
}
inline std::string* HloModuleConfigProto::mutable_fdo_profile() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fdo_profile();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.fdo_profile)
  return _s;
}
inline const std::string& HloModuleConfigProto::_internal_fdo_profile() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fdo_profile_.Get();
}
inline void HloModuleConfigProto::_internal_set_fdo_profile(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.Set(value, GetArena());
}
inline std::string* HloModuleConfigProto::_internal_mutable_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.fdo_profile_.Mutable( GetArena());
}
inline std::string* HloModuleConfigProto::release_fdo_profile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.fdo_profile)
  return _impl_.fdo_profile_.Release();
}
inline void HloModuleConfigProto::set_allocated_fdo_profile(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fdo_profile_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fdo_profile_.IsDefault()) {
          _impl_.fdo_profile_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.fdo_profile)
}

// int64 device_memory_size = 32;
inline void HloModuleConfigProto::clear_device_memory_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_memory_size_ = ::int64_t{0};
}
inline ::int64_t HloModuleConfigProto::device_memory_size() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.device_memory_size)
  return _internal_device_memory_size();
}
inline void HloModuleConfigProto::set_device_memory_size(::int64_t value) {
  _internal_set_device_memory_size(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.device_memory_size)
}
inline ::int64_t HloModuleConfigProto::_internal_device_memory_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_memory_size_;
}
inline void HloModuleConfigProto::_internal_set_device_memory_size(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_memory_size_ = value;
}

// bool use_shardy_partitioner = 34;
inline void HloModuleConfigProto::clear_use_shardy_partitioner() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shardy_partitioner_ = false;
}
inline bool HloModuleConfigProto::use_shardy_partitioner() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_shardy_partitioner)
  return _internal_use_shardy_partitioner();
}
inline void HloModuleConfigProto::set_use_shardy_partitioner(bool value) {
  _internal_set_use_shardy_partitioner(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_shardy_partitioner)
}
inline bool HloModuleConfigProto::_internal_use_shardy_partitioner() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_shardy_partitioner_;
}
inline void HloModuleConfigProto::_internal_set_use_shardy_partitioner(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shardy_partitioner_ = value;
}

// .xla.ShardingConfigProto sharding_config = 38;
inline bool HloModuleConfigProto::has_sharding_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sharding_config_ != nullptr);
  return value;
}
inline void HloModuleConfigProto::clear_sharding_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.sharding_config_ != nullptr) _impl_.sharding_config_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::xla::ShardingConfigProto& HloModuleConfigProto::_internal_sharding_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::ShardingConfigProto* p = _impl_.sharding_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ShardingConfigProto&>(::xla::_ShardingConfigProto_default_instance_);
}
inline const ::xla::ShardingConfigProto& HloModuleConfigProto::sharding_config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.sharding_config)
  return _internal_sharding_config();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_sharding_config(::xla::ShardingConfigProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sharding_config_);
  }
  _impl_.sharding_config_ = reinterpret_cast<::xla::ShardingConfigProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.sharding_config)
}
inline ::xla::ShardingConfigProto* HloModuleConfigProto::release_sharding_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::xla::ShardingConfigProto* released = _impl_.sharding_config_;
  _impl_.sharding_config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::ShardingConfigProto* HloModuleConfigProto::unsafe_arena_release_sharding_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.sharding_config)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::xla::ShardingConfigProto* temp = _impl_.sharding_config_;
  _impl_.sharding_config_ = nullptr;
  return temp;
}
inline ::xla::ShardingConfigProto* HloModuleConfigProto::_internal_mutable_sharding_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.sharding_config_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::ShardingConfigProto>(GetArena());
    _impl_.sharding_config_ = reinterpret_cast<::xla::ShardingConfigProto*>(p);
  }
  return _impl_.sharding_config_;
}
inline ::xla::ShardingConfigProto* HloModuleConfigProto::mutable_sharding_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000010u;
  ::xla::ShardingConfigProto* _msg = _internal_mutable_sharding_config();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.sharding_config)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_sharding_config(::xla::ShardingConfigProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.sharding_config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.sharding_config_ = reinterpret_cast<::xla::ShardingConfigProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.sharding_config)
}

// .xla.ScheduleConfigProto schedule_config = 41;
inline bool HloModuleConfigProto::has_schedule_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.schedule_config_ != nullptr);
  return value;
}
inline void HloModuleConfigProto::clear_schedule_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.schedule_config_ != nullptr) _impl_.schedule_config_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::xla::ScheduleConfigProto& HloModuleConfigProto::_internal_schedule_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::ScheduleConfigProto* p = _impl_.schedule_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ScheduleConfigProto&>(::xla::_ScheduleConfigProto_default_instance_);
}
inline const ::xla::ScheduleConfigProto& HloModuleConfigProto::schedule_config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.schedule_config)
  return _internal_schedule_config();
}
inline void HloModuleConfigProto::unsafe_arena_set_allocated_schedule_config(::xla::ScheduleConfigProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.schedule_config_);
  }
  _impl_.schedule_config_ = reinterpret_cast<::xla::ScheduleConfigProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.schedule_config)
}
inline ::xla::ScheduleConfigProto* HloModuleConfigProto::release_schedule_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::xla::ScheduleConfigProto* released = _impl_.schedule_config_;
  _impl_.schedule_config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::ScheduleConfigProto* HloModuleConfigProto::unsafe_arena_release_schedule_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.schedule_config)

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::xla::ScheduleConfigProto* temp = _impl_.schedule_config_;
  _impl_.schedule_config_ = nullptr;
  return temp;
}
inline ::xla::ScheduleConfigProto* HloModuleConfigProto::_internal_mutable_schedule_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.schedule_config_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::ScheduleConfigProto>(GetArena());
    _impl_.schedule_config_ = reinterpret_cast<::xla::ScheduleConfigProto*>(p);
  }
  return _impl_.schedule_config_;
}
inline ::xla::ScheduleConfigProto* HloModuleConfigProto::mutable_schedule_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000020u;
  ::xla::ScheduleConfigProto* _msg = _internal_mutable_schedule_config();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.schedule_config)
  return _msg;
}
inline void HloModuleConfigProto::set_allocated_schedule_config(::xla::ScheduleConfigProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.schedule_config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }

  _impl_.schedule_config_ = reinterpret_cast<::xla::ScheduleConfigProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.schedule_config)
}

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

// HloModuleProtoWithConfig

// .xla.HloModuleProto hlo_module = 1;
inline bool HloModuleProtoWithConfig::has_hlo_module() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hlo_module_ != nullptr);
  return value;
}
inline const ::xla::HloModuleProto& HloModuleProtoWithConfig::_internal_hlo_module() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::HloModuleProto* p = _impl_.hlo_module_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleProto&>(::xla::_HloModuleProto_default_instance_);
}
inline const ::xla::HloModuleProto& HloModuleProtoWithConfig::hlo_module() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleProtoWithConfig.hlo_module)
  return _internal_hlo_module();
}
inline void HloModuleProtoWithConfig::unsafe_arena_set_allocated_hlo_module(::xla::HloModuleProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hlo_module_);
  }
  _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProtoWithConfig.hlo_module)
}
inline ::xla::HloModuleProto* HloModuleProtoWithConfig::release_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::HloModuleProto* released = _impl_.hlo_module_;
  _impl_.hlo_module_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::HloModuleProto* HloModuleProtoWithConfig::unsafe_arena_release_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleProtoWithConfig.hlo_module)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::HloModuleProto* temp = _impl_.hlo_module_;
  _impl_.hlo_module_ = nullptr;
  return temp;
}
inline ::xla::HloModuleProto* HloModuleProtoWithConfig::_internal_mutable_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.hlo_module_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::HloModuleProto>(GetArena());
    _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(p);
  }
  return _impl_.hlo_module_;
}
inline ::xla::HloModuleProto* HloModuleProtoWithConfig::mutable_hlo_module() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProtoWithConfig.hlo_module)
  return _msg;
}
inline void HloModuleProtoWithConfig::set_allocated_hlo_module(::xla::HloModuleProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hlo_module_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProtoWithConfig.hlo_module)
}

// .xla.HloModuleConfigProto config = 2;
inline bool HloModuleProtoWithConfig::has_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.config_ != nullptr);
  return value;
}
inline void HloModuleProtoWithConfig::clear_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ != nullptr) _impl_.config_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::xla::HloModuleConfigProto& HloModuleProtoWithConfig::_internal_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::HloModuleConfigProto* p = _impl_.config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleConfigProto&>(::xla::_HloModuleConfigProto_default_instance_);
}
inline const ::xla::HloModuleConfigProto& HloModuleProtoWithConfig::config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.HloModuleProtoWithConfig.config)
  return _internal_config();
}
inline void HloModuleProtoWithConfig::unsafe_arena_set_allocated_config(::xla::HloModuleConfigProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }
  _impl_.config_ = reinterpret_cast<::xla::HloModuleConfigProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProtoWithConfig.config)
}
inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::HloModuleConfigProto* released = _impl_.config_;
  _impl_.config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::unsafe_arena_release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.HloModuleProtoWithConfig.config)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::xla::HloModuleConfigProto* temp = _impl_.config_;
  _impl_.config_ = nullptr;
  return temp;
}
inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::_internal_mutable_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::HloModuleConfigProto>(GetArena());
    _impl_.config_ = reinterpret_cast<::xla::HloModuleConfigProto*>(p);
  }
  return _impl_.config_;
}
inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::mutable_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::xla::HloModuleConfigProto* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProtoWithConfig.config)
  return _msg;
}
inline void HloModuleProtoWithConfig::set_allocated_config(::xla::HloModuleConfigProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.config_ = reinterpret_cast<::xla::HloModuleConfigProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProtoWithConfig.config)
}

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

// ScheduleProto_Instruction

// int64 id = 1;
inline void ScheduleProto_Instruction::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_Instruction::id() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.id)
  return _internal_id();
}
inline void ScheduleProto_Instruction::set_id(::int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.id)
}
inline ::int64_t ScheduleProto_Instruction::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void ScheduleProto_Instruction::_internal_set_id(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// double start_timestamp_cycles = 2;
inline void ScheduleProto_Instruction::clear_start_timestamp_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.start_timestamp_cycles_ = 0;
}
inline double ScheduleProto_Instruction::start_timestamp_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.start_timestamp_cycles)
  return _internal_start_timestamp_cycles();
}
inline void ScheduleProto_Instruction::set_start_timestamp_cycles(double value) {
  _internal_set_start_timestamp_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.start_timestamp_cycles)
}
inline double ScheduleProto_Instruction::_internal_start_timestamp_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.start_timestamp_cycles_;
}
inline void ScheduleProto_Instruction::_internal_set_start_timestamp_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.start_timestamp_cycles_ = value;
}

// double end_timestamp_cycles = 3;
inline void ScheduleProto_Instruction::clear_end_timestamp_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.end_timestamp_cycles_ = 0;
}
inline double ScheduleProto_Instruction::end_timestamp_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.end_timestamp_cycles)
  return _internal_end_timestamp_cycles();
}
inline void ScheduleProto_Instruction::set_end_timestamp_cycles(double value) {
  _internal_set_end_timestamp_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.end_timestamp_cycles)
}
inline double ScheduleProto_Instruction::_internal_end_timestamp_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.end_timestamp_cycles_;
}
inline void ScheduleProto_Instruction::_internal_set_end_timestamp_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.end_timestamp_cycles_ = value;
}

// int64 memory_usage_after = 5;
inline void ScheduleProto_Instruction::clear_memory_usage_after() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_usage_after_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_Instruction::memory_usage_after() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.memory_usage_after)
  return _internal_memory_usage_after();
}
inline void ScheduleProto_Instruction::set_memory_usage_after(::int64_t value) {
  _internal_set_memory_usage_after(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.memory_usage_after)
}
inline ::int64_t ScheduleProto_Instruction::_internal_memory_usage_after() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.memory_usage_after_;
}
inline void ScheduleProto_Instruction::_internal_set_memory_usage_after(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_usage_after_ = value;
}

// int64 peak_memory_after = 6;
inline void ScheduleProto_Instruction::clear_peak_memory_after() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.peak_memory_after_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_Instruction::peak_memory_after() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.peak_memory_after)
  return _internal_peak_memory_after();
}
inline void ScheduleProto_Instruction::set_peak_memory_after(::int64_t value) {
  _internal_set_peak_memory_after(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.peak_memory_after)
}
inline ::int64_t ScheduleProto_Instruction::_internal_peak_memory_after() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.peak_memory_after_;
}
inline void ScheduleProto_Instruction::_internal_set_peak_memory_after(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.peak_memory_after_ = value;
}

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

// ScheduleProto_SchedulerStatisticsProto

// double all_gather_wasted_cycles = 1;
inline void ScheduleProto_SchedulerStatisticsProto::clear_all_gather_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_gather_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::all_gather_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.all_gather_wasted_cycles)
  return _internal_all_gather_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_all_gather_wasted_cycles(double value) {
  _internal_set_all_gather_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.all_gather_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_all_gather_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.all_gather_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_all_gather_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_gather_wasted_cycles_ = value;
}

// double all_reduce_wasted_cycles = 2;
inline void ScheduleProto_SchedulerStatisticsProto::clear_all_reduce_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_reduce_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::all_reduce_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.all_reduce_wasted_cycles)
  return _internal_all_reduce_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_all_reduce_wasted_cycles(double value) {
  _internal_set_all_reduce_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.all_reduce_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_all_reduce_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.all_reduce_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_all_reduce_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_reduce_wasted_cycles_ = value;
}

// double collective_broadcast_wasted_cycles = 3;
inline void ScheduleProto_SchedulerStatisticsProto::clear_collective_broadcast_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.collective_broadcast_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::collective_broadcast_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.collective_broadcast_wasted_cycles)
  return _internal_collective_broadcast_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_collective_broadcast_wasted_cycles(double value) {
  _internal_set_collective_broadcast_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.collective_broadcast_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_collective_broadcast_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.collective_broadcast_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_collective_broadcast_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.collective_broadcast_wasted_cycles_ = value;
}

// double collective_permute_wasted_cycles = 4;
inline void ScheduleProto_SchedulerStatisticsProto::clear_collective_permute_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.collective_permute_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::collective_permute_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.collective_permute_wasted_cycles)
  return _internal_collective_permute_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_collective_permute_wasted_cycles(double value) {
  _internal_set_collective_permute_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.collective_permute_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_collective_permute_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.collective_permute_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_collective_permute_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.collective_permute_wasted_cycles_ = value;
}

// double all_to_all_wasted_cycles = 5;
inline void ScheduleProto_SchedulerStatisticsProto::clear_all_to_all_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_to_all_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::all_to_all_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.all_to_all_wasted_cycles)
  return _internal_all_to_all_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_all_to_all_wasted_cycles(double value) {
  _internal_set_all_to_all_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.all_to_all_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_all_to_all_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.all_to_all_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_all_to_all_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.all_to_all_wasted_cycles_ = value;
}

// double ragged_all_to_all_wasted_cycles = 6;
inline void ScheduleProto_SchedulerStatisticsProto::clear_ragged_all_to_all_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ragged_all_to_all_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::ragged_all_to_all_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.ragged_all_to_all_wasted_cycles)
  return _internal_ragged_all_to_all_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_ragged_all_to_all_wasted_cycles(double value) {
  _internal_set_ragged_all_to_all_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.ragged_all_to_all_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_ragged_all_to_all_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ragged_all_to_all_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_ragged_all_to_all_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ragged_all_to_all_wasted_cycles_ = value;
}

// double reduce_scatter_wasted_cycles = 7;
inline void ScheduleProto_SchedulerStatisticsProto::clear_reduce_scatter_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.reduce_scatter_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::reduce_scatter_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.reduce_scatter_wasted_cycles)
  return _internal_reduce_scatter_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_reduce_scatter_wasted_cycles(double value) {
  _internal_set_reduce_scatter_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.reduce_scatter_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_reduce_scatter_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.reduce_scatter_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_reduce_scatter_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.reduce_scatter_wasted_cycles_ = value;
}

// double send_wasted_cycles = 8;
inline void ScheduleProto_SchedulerStatisticsProto::clear_send_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.send_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::send_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.send_wasted_cycles)
  return _internal_send_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_send_wasted_cycles(double value) {
  _internal_set_send_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.send_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_send_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.send_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_send_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.send_wasted_cycles_ = value;
}

// double recv_wasted_cycles = 9;
inline void ScheduleProto_SchedulerStatisticsProto::clear_recv_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recv_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::recv_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.recv_wasted_cycles)
  return _internal_recv_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_recv_wasted_cycles(double value) {
  _internal_set_recv_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.recv_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_recv_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.recv_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_recv_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recv_wasted_cycles_ = value;
}

// double total_wasted_cycles = 10;
inline void ScheduleProto_SchedulerStatisticsProto::clear_total_wasted_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_wasted_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::total_wasted_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.total_wasted_cycles)
  return _internal_total_wasted_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_total_wasted_cycles(double value) {
  _internal_set_total_wasted_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.total_wasted_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_total_wasted_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.total_wasted_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_total_wasted_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_wasted_cycles_ = value;
}

// double total_cycles = 11;
inline void ScheduleProto_SchedulerStatisticsProto::clear_total_cycles() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_cycles_ = 0;
}
inline double ScheduleProto_SchedulerStatisticsProto::total_cycles() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.total_cycles)
  return _internal_total_cycles();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_total_cycles(double value) {
  _internal_set_total_cycles(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.total_cycles)
}
inline double ScheduleProto_SchedulerStatisticsProto::_internal_total_cycles() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.total_cycles_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_total_cycles(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_cycles_ = value;
}

// int64 memory_pressure_peak = 12;
inline void ScheduleProto_SchedulerStatisticsProto::clear_memory_pressure_peak() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_pressure_peak_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_SchedulerStatisticsProto::memory_pressure_peak() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.SchedulerStatisticsProto.memory_pressure_peak)
  return _internal_memory_pressure_peak();
}
inline void ScheduleProto_SchedulerStatisticsProto::set_memory_pressure_peak(::int64_t value) {
  _internal_set_memory_pressure_peak(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.SchedulerStatisticsProto.memory_pressure_peak)
}
inline ::int64_t ScheduleProto_SchedulerStatisticsProto::_internal_memory_pressure_peak() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.memory_pressure_peak_;
}
inline void ScheduleProto_SchedulerStatisticsProto::_internal_set_memory_pressure_peak(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.memory_pressure_peak_ = value;
}

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

// ScheduleProto_ComputationScheduleProto

// int64 computation_id = 1;
inline void ScheduleProto_ComputationScheduleProto::clear_computation_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.computation_id_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_ComputationScheduleProto::computation_id() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.ComputationScheduleProto.computation_id)
  return _internal_computation_id();
}
inline void ScheduleProto_ComputationScheduleProto::set_computation_id(::int64_t value) {
  _internal_set_computation_id(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.ComputationScheduleProto.computation_id)
}
inline ::int64_t ScheduleProto_ComputationScheduleProto::_internal_computation_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.computation_id_;
}
inline void ScheduleProto_ComputationScheduleProto::_internal_set_computation_id(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.computation_id_ = value;
}

// repeated .xla.ScheduleProto.Instruction instructions = 2;
inline int ScheduleProto_ComputationScheduleProto::_internal_instructions_size() const {
  return _internal_instructions().size();
}
inline int ScheduleProto_ComputationScheduleProto::instructions_size() const {
  return _internal_instructions_size();
}
inline void ScheduleProto_ComputationScheduleProto::clear_instructions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.instructions_.Clear();
}
inline ::xla::ScheduleProto_Instruction* ScheduleProto_ComputationScheduleProto::mutable_instructions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.ComputationScheduleProto.instructions)
  return _internal_mutable_instructions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>* ScheduleProto_ComputationScheduleProto::mutable_instructions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ScheduleProto.ComputationScheduleProto.instructions)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_instructions();
}
inline const ::xla::ScheduleProto_Instruction& ScheduleProto_ComputationScheduleProto::instructions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.ComputationScheduleProto.instructions)
  return _internal_instructions().Get(index);
}
inline ::xla::ScheduleProto_Instruction* ScheduleProto_ComputationScheduleProto::add_instructions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::ScheduleProto_Instruction* _add = _internal_mutable_instructions()->Add();
  // @@protoc_insertion_point(field_add:xla.ScheduleProto.ComputationScheduleProto.instructions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>& ScheduleProto_ComputationScheduleProto::instructions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ScheduleProto.ComputationScheduleProto.instructions)
  return _internal_instructions();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>&
ScheduleProto_ComputationScheduleProto::_internal_instructions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.instructions_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_Instruction>*
ScheduleProto_ComputationScheduleProto::_internal_mutable_instructions() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.instructions_;
}

// .xla.ScheduleProto.SchedulerStatisticsProto scheduler_statistics = 3;
inline bool ScheduleProto_ComputationScheduleProto::has_scheduler_statistics() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.scheduler_statistics_ != nullptr);
  return value;
}
inline void ScheduleProto_ComputationScheduleProto::clear_scheduler_statistics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scheduler_statistics_ != nullptr) _impl_.scheduler_statistics_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::xla::ScheduleProto_SchedulerStatisticsProto& ScheduleProto_ComputationScheduleProto::_internal_scheduler_statistics() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::ScheduleProto_SchedulerStatisticsProto* p = _impl_.scheduler_statistics_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ScheduleProto_SchedulerStatisticsProto&>(::xla::_ScheduleProto_SchedulerStatisticsProto_default_instance_);
}
inline const ::xla::ScheduleProto_SchedulerStatisticsProto& ScheduleProto_ComputationScheduleProto::scheduler_statistics() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.ComputationScheduleProto.scheduler_statistics)
  return _internal_scheduler_statistics();
}
inline void ScheduleProto_ComputationScheduleProto::unsafe_arena_set_allocated_scheduler_statistics(::xla::ScheduleProto_SchedulerStatisticsProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scheduler_statistics_);
  }
  _impl_.scheduler_statistics_ = reinterpret_cast<::xla::ScheduleProto_SchedulerStatisticsProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ScheduleProto.ComputationScheduleProto.scheduler_statistics)
}
inline ::xla::ScheduleProto_SchedulerStatisticsProto* ScheduleProto_ComputationScheduleProto::release_scheduler_statistics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ScheduleProto_SchedulerStatisticsProto* released = _impl_.scheduler_statistics_;
  _impl_.scheduler_statistics_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::ScheduleProto_SchedulerStatisticsProto* ScheduleProto_ComputationScheduleProto::unsafe_arena_release_scheduler_statistics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ScheduleProto.ComputationScheduleProto.scheduler_statistics)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::ScheduleProto_SchedulerStatisticsProto* temp = _impl_.scheduler_statistics_;
  _impl_.scheduler_statistics_ = nullptr;
  return temp;
}
inline ::xla::ScheduleProto_SchedulerStatisticsProto* ScheduleProto_ComputationScheduleProto::_internal_mutable_scheduler_statistics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scheduler_statistics_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::ScheduleProto_SchedulerStatisticsProto>(GetArena());
    _impl_.scheduler_statistics_ = reinterpret_cast<::xla::ScheduleProto_SchedulerStatisticsProto*>(p);
  }
  return _impl_.scheduler_statistics_;
}
inline ::xla::ScheduleProto_SchedulerStatisticsProto* ScheduleProto_ComputationScheduleProto::mutable_scheduler_statistics() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::ScheduleProto_SchedulerStatisticsProto* _msg = _internal_mutable_scheduler_statistics();
  // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.ComputationScheduleProto.scheduler_statistics)
  return _msg;
}
inline void ScheduleProto_ComputationScheduleProto::set_allocated_scheduler_statistics(::xla::ScheduleProto_SchedulerStatisticsProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.scheduler_statistics_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.scheduler_statistics_ = reinterpret_cast<::xla::ScheduleProto_SchedulerStatisticsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.ScheduleProto.ComputationScheduleProto.scheduler_statistics)
}

// int64 cycles_per_microsecond = 4;
inline void ScheduleProto_ComputationScheduleProto::clear_cycles_per_microsecond() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cycles_per_microsecond_ = ::int64_t{0};
}
inline ::int64_t ScheduleProto_ComputationScheduleProto::cycles_per_microsecond() const {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.ComputationScheduleProto.cycles_per_microsecond)
  return _internal_cycles_per_microsecond();
}
inline void ScheduleProto_ComputationScheduleProto::set_cycles_per_microsecond(::int64_t value) {
  _internal_set_cycles_per_microsecond(value);
  // @@protoc_insertion_point(field_set:xla.ScheduleProto.ComputationScheduleProto.cycles_per_microsecond)
}
inline ::int64_t ScheduleProto_ComputationScheduleProto::_internal_cycles_per_microsecond() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cycles_per_microsecond_;
}
inline void ScheduleProto_ComputationScheduleProto::_internal_set_cycles_per_microsecond(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cycles_per_microsecond_ = value;
}

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

// ScheduleProto

// .xla.HloModuleProto hlo_module = 1;
inline bool ScheduleProto::has_hlo_module() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hlo_module_ != nullptr);
  return value;
}
inline const ::xla::HloModuleProto& ScheduleProto::_internal_hlo_module() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::HloModuleProto* p = _impl_.hlo_module_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleProto&>(::xla::_HloModuleProto_default_instance_);
}
inline const ::xla::HloModuleProto& ScheduleProto::hlo_module() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.hlo_module)
  return _internal_hlo_module();
}
inline void ScheduleProto::unsafe_arena_set_allocated_hlo_module(::xla::HloModuleProto* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hlo_module_);
  }
  _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ScheduleProto.hlo_module)
}
inline ::xla::HloModuleProto* ScheduleProto::release_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::HloModuleProto* released = _impl_.hlo_module_;
  _impl_.hlo_module_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::HloModuleProto* ScheduleProto::unsafe_arena_release_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ScheduleProto.hlo_module)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::HloModuleProto* temp = _impl_.hlo_module_;
  _impl_.hlo_module_ = nullptr;
  return temp;
}
inline ::xla::HloModuleProto* ScheduleProto::_internal_mutable_hlo_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.hlo_module_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::HloModuleProto>(GetArena());
    _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(p);
  }
  return _impl_.hlo_module_;
}
inline ::xla::HloModuleProto* ScheduleProto::mutable_hlo_module() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module();
  // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.hlo_module)
  return _msg;
}
inline void ScheduleProto::set_allocated_hlo_module(::xla::HloModuleProto* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hlo_module_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.hlo_module_ = reinterpret_cast<::xla::HloModuleProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.ScheduleProto.hlo_module)
}

// repeated .xla.ScheduleProto.ComputationScheduleProto computation_schedules = 2;
inline int ScheduleProto::_internal_computation_schedules_size() const {
  return _internal_computation_schedules().size();
}
inline int ScheduleProto::computation_schedules_size() const {
  return _internal_computation_schedules_size();
}
inline void ScheduleProto::clear_computation_schedules() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.computation_schedules_.Clear();
}
inline ::xla::ScheduleProto_ComputationScheduleProto* ScheduleProto::mutable_computation_schedules(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.computation_schedules)
  return _internal_mutable_computation_schedules()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>* ScheduleProto::mutable_computation_schedules()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ScheduleProto.computation_schedules)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_computation_schedules();
}
inline const ::xla::ScheduleProto_ComputationScheduleProto& ScheduleProto::computation_schedules(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleProto.computation_schedules)
  return _internal_computation_schedules().Get(index);
}
inline ::xla::ScheduleProto_ComputationScheduleProto* ScheduleProto::add_computation_schedules() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::ScheduleProto_ComputationScheduleProto* _add = _internal_mutable_computation_schedules()->Add();
  // @@protoc_insertion_point(field_add:xla.ScheduleProto.computation_schedules)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>& ScheduleProto::computation_schedules() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ScheduleProto.computation_schedules)
  return _internal_computation_schedules();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>&
ScheduleProto::_internal_computation_schedules() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.computation_schedules_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleProto_ComputationScheduleProto>*
ScheduleProto::_internal_mutable_computation_schedules() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.computation_schedules_;
}

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

// NodeShardingConfigProto

// .xla.OpSharding sharding = 1;
inline bool NodeShardingConfigProto::has_sharding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sharding_ != nullptr);
  return value;
}
inline const ::xla::OpSharding& NodeShardingConfigProto::_internal_sharding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::xla::OpSharding* p = _impl_.sharding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpSharding&>(::xla::_OpSharding_default_instance_);
}
inline const ::xla::OpSharding& NodeShardingConfigProto::sharding() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.NodeShardingConfigProto.sharding)
  return _internal_sharding();
}
inline void NodeShardingConfigProto::unsafe_arena_set_allocated_sharding(::xla::OpSharding* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sharding_);
  }
  _impl_.sharding_ = reinterpret_cast<::xla::OpSharding*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.NodeShardingConfigProto.sharding)
}
inline ::xla::OpSharding* NodeShardingConfigProto::release_sharding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::OpSharding* released = _impl_.sharding_;
  _impl_.sharding_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::xla::OpSharding* NodeShardingConfigProto::unsafe_arena_release_sharding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.NodeShardingConfigProto.sharding)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::OpSharding* temp = _impl_.sharding_;
  _impl_.sharding_ = nullptr;
  return temp;
}
inline ::xla::OpSharding* NodeShardingConfigProto::_internal_mutable_sharding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.sharding_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::xla::OpSharding>(GetArena());
    _impl_.sharding_ = reinterpret_cast<::xla::OpSharding*>(p);
  }
  return _impl_.sharding_;
}
inline ::xla::OpSharding* NodeShardingConfigProto::mutable_sharding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::xla::OpSharding* _msg = _internal_mutable_sharding();
  // @@protoc_insertion_point(field_mutable:xla.NodeShardingConfigProto.sharding)
  return _msg;
}
inline void NodeShardingConfigProto::set_allocated_sharding(::xla::OpSharding* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sharding_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.sharding_ = reinterpret_cast<::xla::OpSharding*>(value);
  // @@protoc_insertion_point(field_set_allocated:xla.NodeShardingConfigProto.sharding)
}

// repeated .xla.NodeShardingConfigProto nodes = 2;
inline int NodeShardingConfigProto::_internal_nodes_size() const {
  return _internal_nodes().size();
}
inline int NodeShardingConfigProto::nodes_size() const {
  return _internal_nodes_size();
}
inline void NodeShardingConfigProto::clear_nodes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nodes_.Clear();
}
inline ::xla::NodeShardingConfigProto* NodeShardingConfigProto::mutable_nodes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.NodeShardingConfigProto.nodes)
  return _internal_mutable_nodes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* NodeShardingConfigProto::mutable_nodes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.NodeShardingConfigProto.nodes)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_nodes();
}
inline const ::xla::NodeShardingConfigProto& NodeShardingConfigProto::nodes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.NodeShardingConfigProto.nodes)
  return _internal_nodes().Get(index);
}
inline ::xla::NodeShardingConfigProto* NodeShardingConfigProto::add_nodes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::NodeShardingConfigProto* _add = _internal_mutable_nodes()->Add();
  // @@protoc_insertion_point(field_add:xla.NodeShardingConfigProto.nodes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& NodeShardingConfigProto::nodes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.NodeShardingConfigProto.nodes)
  return _internal_nodes();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>&
NodeShardingConfigProto::_internal_nodes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.nodes_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>*
NodeShardingConfigProto::_internal_mutable_nodes() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.nodes_;
}

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

// ShardingConfigProto

// repeated .xla.NodeShardingConfigProto nodes = 1;
inline int ShardingConfigProto::_internal_nodes_size() const {
  return _internal_nodes().size();
}
inline int ShardingConfigProto::nodes_size() const {
  return _internal_nodes_size();
}
inline void ShardingConfigProto::clear_nodes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nodes_.Clear();
}
inline ::xla::NodeShardingConfigProto* ShardingConfigProto::mutable_nodes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ShardingConfigProto.nodes)
  return _internal_mutable_nodes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>* ShardingConfigProto::mutable_nodes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ShardingConfigProto.nodes)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_nodes();
}
inline const ::xla::NodeShardingConfigProto& ShardingConfigProto::nodes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ShardingConfigProto.nodes)
  return _internal_nodes().Get(index);
}
inline ::xla::NodeShardingConfigProto* ShardingConfigProto::add_nodes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::NodeShardingConfigProto* _add = _internal_mutable_nodes()->Add();
  // @@protoc_insertion_point(field_add:xla.ShardingConfigProto.nodes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>& ShardingConfigProto::nodes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ShardingConfigProto.nodes)
  return _internal_nodes();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>&
ShardingConfigProto::_internal_nodes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.nodes_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::NodeShardingConfigProto>*
ShardingConfigProto::_internal_mutable_nodes() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.nodes_;
}

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

// ScheduleConfigProto_Instruction

// string name = 1;
inline void ScheduleConfigProto_Instruction::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ScheduleConfigProto_Instruction::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleConfigProto.Instruction.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ScheduleConfigProto_Instruction::set_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:xla.ScheduleConfigProto.Instruction.name)
}
inline std::string* ScheduleConfigProto_Instruction::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:xla.ScheduleConfigProto.Instruction.name)
  return _s;
}
inline const std::string& ScheduleConfigProto_Instruction::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void ScheduleConfigProto_Instruction::_internal_set_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline std::string* ScheduleConfigProto_Instruction::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* ScheduleConfigProto_Instruction::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:xla.ScheduleConfigProto.Instruction.name)
  return _impl_.name_.Release();
}
inline void ScheduleConfigProto_Instruction::set_allocated_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.ScheduleConfigProto.Instruction.name)
}

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

// ScheduleConfigProto

// repeated .xla.ScheduleConfigProto.Instruction sequence = 1;
inline int ScheduleConfigProto::_internal_sequence_size() const {
  return _internal_sequence().size();
}
inline int ScheduleConfigProto::sequence_size() const {
  return _internal_sequence_size();
}
inline void ScheduleConfigProto::clear_sequence() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_.Clear();
}
inline ::xla::ScheduleConfigProto_Instruction* ScheduleConfigProto::mutable_sequence(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:xla.ScheduleConfigProto.sequence)
  return _internal_mutable_sequence()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>* ScheduleConfigProto::mutable_sequence()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:xla.ScheduleConfigProto.sequence)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_sequence();
}
inline const ::xla::ScheduleConfigProto_Instruction& ScheduleConfigProto::sequence(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:xla.ScheduleConfigProto.sequence)
  return _internal_sequence().Get(index);
}
inline ::xla::ScheduleConfigProto_Instruction* ScheduleConfigProto::add_sequence() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::xla::ScheduleConfigProto_Instruction* _add = _internal_mutable_sequence()->Add();
  // @@protoc_insertion_point(field_add:xla.ScheduleConfigProto.sequence)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>& ScheduleConfigProto::sequence() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:xla.ScheduleConfigProto.sequence)
  return _internal_sequence();
}
inline const ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>&
ScheduleConfigProto::_internal_sequence() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sequence_;
}
inline ::google::protobuf::RepeatedPtrField<::xla::ScheduleConfigProto_Instruction>*
ScheduleConfigProto::_internal_mutable_sequence() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.sequence_;
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace xla


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::xla::DebugOptions_CollectiveOpType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_CollectiveOpType>() {
  return ::xla::DebugOptions_CollectiveOpType_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_CommandBufferCmdType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_CommandBufferCmdType>() {
  return ::xla::DebugOptions_CommandBufferCmdType_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_LibNvJitLinkMode> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_LibNvJitLinkMode>() {
  return ::xla::DebugOptions_LibNvJitLinkMode_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_PGLEStrictnessLevel> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_PGLEStrictnessLevel>() {
  return ::xla::DebugOptions_PGLEStrictnessLevel_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_ShapeChecks> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_ShapeChecks>() {
  return ::xla::DebugOptions_ShapeChecks_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_WhileLoopUnrolling> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_WhileLoopUnrolling>() {
  return ::xla::DebugOptions_WhileLoopUnrolling_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_XnnGraphFusionMode> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_XnnGraphFusionMode>() {
  return ::xla::DebugOptions_XnnGraphFusionMode_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_GenericTritonEmitterFeature> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_GenericTritonEmitterFeature>() {
  return ::xla::DebugOptions_GenericTritonEmitterFeature_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_PipelineParallelismOptLevel> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_PipelineParallelismOptLevel>() {
  return ::xla::DebugOptions_PipelineParallelismOptLevel_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_StepMarkerLocation> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_StepMarkerLocation>() {
  return ::xla::DebugOptions_StepMarkerLocation_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_PartitioningAlgorithm> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_PartitioningAlgorithm>() {
  return ::xla::DebugOptions_PartitioningAlgorithm_descriptor();
}
template <>
struct is_proto_enum<::xla::DebugOptions_AutotuneCacheMode> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::DebugOptions_AutotuneCacheMode>() {
  return ::xla::DebugOptions_AutotuneCacheMode_descriptor();
}
template <>
struct is_proto_enum<::xla::ExecutionOptions_EffortLevel> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::ExecutionOptions_EffortLevel>() {
  return ::xla::ExecutionOptions_EffortLevel_descriptor();
}
template <>
struct is_proto_enum<::xla::HloModuleConfigProto_FusionConfigCollection> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::xla::HloModuleConfigProto_FusionConfigCollection>() {
  return ::xla::HloModuleConfigProto_FusionConfigCollection_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto_2epb_2eh