// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/core/protobuf/config.proto

#ifndef PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED
#define PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3004000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3004000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "tensorflow/core/framework/cost_graph.pb.h"
#include "tensorflow/core/framework/graph.pb.h"
#include "tensorflow/core/framework/step_stats.pb.h"
#include "tensorflow/core/protobuf/debug.pb.h"
#include "tensorflow/core/protobuf/cluster.pb.h"
#include "tensorflow/core/protobuf/rewriter_config.pb.h"
// @@protoc_insertion_point(includes)
namespace tensorflow {
class ConfigProto;
class ConfigProtoDefaultTypeInternal;
extern ConfigProtoDefaultTypeInternal _ConfigProto_default_instance_;
class ConfigProto_DeviceCountEntry;
class ConfigProto_DeviceCountEntryDefaultTypeInternal;
extern ConfigProto_DeviceCountEntryDefaultTypeInternal _ConfigProto_DeviceCountEntry_default_instance_;
class GPUOptions;
class GPUOptionsDefaultTypeInternal;
extern GPUOptionsDefaultTypeInternal _GPUOptions_default_instance_;
class GraphOptions;
class GraphOptionsDefaultTypeInternal;
extern GraphOptionsDefaultTypeInternal _GraphOptions_default_instance_;
class OptimizerOptions;
class OptimizerOptionsDefaultTypeInternal;
extern OptimizerOptionsDefaultTypeInternal _OptimizerOptions_default_instance_;
class RPCOptions;
class RPCOptionsDefaultTypeInternal;
extern RPCOptionsDefaultTypeInternal _RPCOptions_default_instance_;
class RunMetadata;
class RunMetadataDefaultTypeInternal;
extern RunMetadataDefaultTypeInternal _RunMetadata_default_instance_;
class RunOptions;
class RunOptionsDefaultTypeInternal;
extern RunOptionsDefaultTypeInternal _RunOptions_default_instance_;
class ThreadPoolOptionProto;
class ThreadPoolOptionProtoDefaultTypeInternal;
extern ThreadPoolOptionProtoDefaultTypeInternal _ThreadPoolOptionProto_default_instance_;
}  // namespace tensorflow

namespace tensorflow {

namespace protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static void InitDefaultsImpl();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto

enum OptimizerOptions_Level {
  OptimizerOptions_Level_L1 = 0,
  OptimizerOptions_Level_L0 = -1,
  OptimizerOptions_Level_OptimizerOptions_Level_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  OptimizerOptions_Level_OptimizerOptions_Level_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool OptimizerOptions_Level_IsValid(int value);
const OptimizerOptions_Level OptimizerOptions_Level_Level_MIN = OptimizerOptions_Level_L0;
const OptimizerOptions_Level OptimizerOptions_Level_Level_MAX = OptimizerOptions_Level_L1;
const int OptimizerOptions_Level_Level_ARRAYSIZE = OptimizerOptions_Level_Level_MAX + 1;

const ::google::protobuf::EnumDescriptor* OptimizerOptions_Level_descriptor();
inline const ::std::string& OptimizerOptions_Level_Name(OptimizerOptions_Level value) {
  return ::google::protobuf::internal::NameOfEnum(
    OptimizerOptions_Level_descriptor(), value);
}
inline bool OptimizerOptions_Level_Parse(
    const ::std::string& name, OptimizerOptions_Level* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OptimizerOptions_Level>(
    OptimizerOptions_Level_descriptor(), name, value);
}
enum OptimizerOptions_GlobalJitLevel {
  OptimizerOptions_GlobalJitLevel_DEFAULT = 0,
  OptimizerOptions_GlobalJitLevel_OFF = -1,
  OptimizerOptions_GlobalJitLevel_ON_1 = 1,
  OptimizerOptions_GlobalJitLevel_ON_2 = 2,
  OptimizerOptions_GlobalJitLevel_OptimizerOptions_GlobalJitLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  OptimizerOptions_GlobalJitLevel_OptimizerOptions_GlobalJitLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool OptimizerOptions_GlobalJitLevel_IsValid(int value);
const OptimizerOptions_GlobalJitLevel OptimizerOptions_GlobalJitLevel_GlobalJitLevel_MIN = OptimizerOptions_GlobalJitLevel_OFF;
const OptimizerOptions_GlobalJitLevel OptimizerOptions_GlobalJitLevel_GlobalJitLevel_MAX = OptimizerOptions_GlobalJitLevel_ON_2;
const int OptimizerOptions_GlobalJitLevel_GlobalJitLevel_ARRAYSIZE = OptimizerOptions_GlobalJitLevel_GlobalJitLevel_MAX + 1;

const ::google::protobuf::EnumDescriptor* OptimizerOptions_GlobalJitLevel_descriptor();
inline const ::std::string& OptimizerOptions_GlobalJitLevel_Name(OptimizerOptions_GlobalJitLevel value) {
  return ::google::protobuf::internal::NameOfEnum(
    OptimizerOptions_GlobalJitLevel_descriptor(), value);
}
inline bool OptimizerOptions_GlobalJitLevel_Parse(
    const ::std::string& name, OptimizerOptions_GlobalJitLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OptimizerOptions_GlobalJitLevel>(
    OptimizerOptions_GlobalJitLevel_descriptor(), name, value);
}
enum RunOptions_TraceLevel {
  RunOptions_TraceLevel_NO_TRACE = 0,
  RunOptions_TraceLevel_SOFTWARE_TRACE = 1,
  RunOptions_TraceLevel_HARDWARE_TRACE = 2,
  RunOptions_TraceLevel_FULL_TRACE = 3,
  RunOptions_TraceLevel_RunOptions_TraceLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  RunOptions_TraceLevel_RunOptions_TraceLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool RunOptions_TraceLevel_IsValid(int value);
const RunOptions_TraceLevel RunOptions_TraceLevel_TraceLevel_MIN = RunOptions_TraceLevel_NO_TRACE;
const RunOptions_TraceLevel RunOptions_TraceLevel_TraceLevel_MAX = RunOptions_TraceLevel_FULL_TRACE;
const int RunOptions_TraceLevel_TraceLevel_ARRAYSIZE = RunOptions_TraceLevel_TraceLevel_MAX + 1;

const ::google::protobuf::EnumDescriptor* RunOptions_TraceLevel_descriptor();
inline const ::std::string& RunOptions_TraceLevel_Name(RunOptions_TraceLevel value) {
  return ::google::protobuf::internal::NameOfEnum(
    RunOptions_TraceLevel_descriptor(), value);
}
inline bool RunOptions_TraceLevel_Parse(
    const ::std::string& name, RunOptions_TraceLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RunOptions_TraceLevel>(
    RunOptions_TraceLevel_descriptor(), name, value);
}
// ===================================================================

class GPUOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.GPUOptions) */ {
 public:
  GPUOptions();
  virtual ~GPUOptions();

  GPUOptions(const GPUOptions& from);

  inline GPUOptions& operator=(const GPUOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  GPUOptions(GPUOptions&& from) noexcept
    : GPUOptions() {
    *this = ::std::move(from);
  }

  inline GPUOptions& operator=(GPUOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GPUOptions& default_instance();

  static inline const GPUOptions* internal_default_instance() {
    return reinterpret_cast<const GPUOptions*>(
               &_GPUOptions_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  void UnsafeArenaSwap(GPUOptions* other);
  void Swap(GPUOptions* other);
  friend void swap(GPUOptions& a, GPUOptions& b) {
    a.Swap(&b);
  }

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

  inline GPUOptions* New() const PROTOBUF_FINAL { return New(NULL); }

  GPUOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const GPUOptions& from);
  void MergeFrom(const GPUOptions& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(GPUOptions* other);
  protected:
  explicit GPUOptions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // string allocator_type = 2;
  void clear_allocator_type();
  static const int kAllocatorTypeFieldNumber = 2;
  const ::std::string& allocator_type() const;
  void set_allocator_type(const ::std::string& value);
  #if LANG_CXX11
  void set_allocator_type(::std::string&& value);
  #endif
  void set_allocator_type(const char* value);
  void set_allocator_type(const char* value, size_t size);
  ::std::string* mutable_allocator_type();
  ::std::string* release_allocator_type();
  void set_allocated_allocator_type(::std::string* allocator_type);
  ::std::string* unsafe_arena_release_allocator_type();
  void unsafe_arena_set_allocated_allocator_type(
      ::std::string* allocator_type);

  // string visible_device_list = 5;
  void clear_visible_device_list();
  static const int kVisibleDeviceListFieldNumber = 5;
  const ::std::string& visible_device_list() const;
  void set_visible_device_list(const ::std::string& value);
  #if LANG_CXX11
  void set_visible_device_list(::std::string&& value);
  #endif
  void set_visible_device_list(const char* value);
  void set_visible_device_list(const char* value, size_t size);
  ::std::string* mutable_visible_device_list();
  ::std::string* release_visible_device_list();
  void set_allocated_visible_device_list(::std::string* visible_device_list);
  ::std::string* unsafe_arena_release_visible_device_list();
  void unsafe_arena_set_allocated_visible_device_list(
      ::std::string* visible_device_list);

  // double per_process_gpu_memory_fraction = 1;
  void clear_per_process_gpu_memory_fraction();
  static const int kPerProcessGpuMemoryFractionFieldNumber = 1;
  double per_process_gpu_memory_fraction() const;
  void set_per_process_gpu_memory_fraction(double value);

  // int64 deferred_deletion_bytes = 3;
  void clear_deferred_deletion_bytes();
  static const int kDeferredDeletionBytesFieldNumber = 3;
  ::google::protobuf::int64 deferred_deletion_bytes() const;
  void set_deferred_deletion_bytes(::google::protobuf::int64 value);

  // int32 polling_active_delay_usecs = 6;
  void clear_polling_active_delay_usecs();
  static const int kPollingActiveDelayUsecsFieldNumber = 6;
  ::google::protobuf::int32 polling_active_delay_usecs() const;
  void set_polling_active_delay_usecs(::google::protobuf::int32 value);

  // bool allow_growth = 4;
  void clear_allow_growth();
  static const int kAllowGrowthFieldNumber = 4;
  bool allow_growth() const;
  void set_allow_growth(bool value);

  // bool force_gpu_compatible = 8;
  void clear_force_gpu_compatible();
  static const int kForceGpuCompatibleFieldNumber = 8;
  bool force_gpu_compatible() const;
  void set_force_gpu_compatible(bool value);

  // int32 polling_inactive_delay_msecs = 7;
  void clear_polling_inactive_delay_msecs();
  static const int kPollingInactiveDelayMsecsFieldNumber = 7;
  ::google::protobuf::int32 polling_inactive_delay_msecs() const;
  void set_polling_inactive_delay_msecs(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:tensorflow.GPUOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr allocator_type_;
  ::google::protobuf::internal::ArenaStringPtr visible_device_list_;
  double per_process_gpu_memory_fraction_;
  ::google::protobuf::int64 deferred_deletion_bytes_;
  ::google::protobuf::int32 polling_active_delay_usecs_;
  bool allow_growth_;
  bool force_gpu_compatible_;
  ::google::protobuf::int32 polling_inactive_delay_msecs_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class OptimizerOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OptimizerOptions) */ {
 public:
  OptimizerOptions();
  virtual ~OptimizerOptions();

  OptimizerOptions(const OptimizerOptions& from);

  inline OptimizerOptions& operator=(const OptimizerOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OptimizerOptions(OptimizerOptions&& from) noexcept
    : OptimizerOptions() {
    *this = ::std::move(from);
  }

  inline OptimizerOptions& operator=(OptimizerOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OptimizerOptions& default_instance();

  static inline const OptimizerOptions* internal_default_instance() {
    return reinterpret_cast<const OptimizerOptions*>(
               &_OptimizerOptions_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  void UnsafeArenaSwap(OptimizerOptions* other);
  void Swap(OptimizerOptions* other);
  friend void swap(OptimizerOptions& a, OptimizerOptions& b) {
    a.Swap(&b);
  }

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

  inline OptimizerOptions* New() const PROTOBUF_FINAL { return New(NULL); }

  OptimizerOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const OptimizerOptions& from);
  void MergeFrom(const OptimizerOptions& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(OptimizerOptions* other);
  protected:
  explicit OptimizerOptions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

  typedef OptimizerOptions_Level Level;
  static const Level L1 =
    OptimizerOptions_Level_L1;
  static const Level L0 =
    OptimizerOptions_Level_L0;
  static inline bool Level_IsValid(int value) {
    return OptimizerOptions_Level_IsValid(value);
  }
  static const Level Level_MIN =
    OptimizerOptions_Level_Level_MIN;
  static const Level Level_MAX =
    OptimizerOptions_Level_Level_MAX;
  static const int Level_ARRAYSIZE =
    OptimizerOptions_Level_Level_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Level_descriptor() {
    return OptimizerOptions_Level_descriptor();
  }
  static inline const ::std::string& Level_Name(Level value) {
    return OptimizerOptions_Level_Name(value);
  }
  static inline bool Level_Parse(const ::std::string& name,
      Level* value) {
    return OptimizerOptions_Level_Parse(name, value);
  }

  typedef OptimizerOptions_GlobalJitLevel GlobalJitLevel;
  static const GlobalJitLevel DEFAULT =
    OptimizerOptions_GlobalJitLevel_DEFAULT;
  static const GlobalJitLevel OFF =
    OptimizerOptions_GlobalJitLevel_OFF;
  static const GlobalJitLevel ON_1 =
    OptimizerOptions_GlobalJitLevel_ON_1;
  static const GlobalJitLevel ON_2 =
    OptimizerOptions_GlobalJitLevel_ON_2;
  static inline bool GlobalJitLevel_IsValid(int value) {
    return OptimizerOptions_GlobalJitLevel_IsValid(value);
  }
  static const GlobalJitLevel GlobalJitLevel_MIN =
    OptimizerOptions_GlobalJitLevel_GlobalJitLevel_MIN;
  static const GlobalJitLevel GlobalJitLevel_MAX =
    OptimizerOptions_GlobalJitLevel_GlobalJitLevel_MAX;
  static const int GlobalJitLevel_ARRAYSIZE =
    OptimizerOptions_GlobalJitLevel_GlobalJitLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  GlobalJitLevel_descriptor() {
    return OptimizerOptions_GlobalJitLevel_descriptor();
  }
  static inline const ::std::string& GlobalJitLevel_Name(GlobalJitLevel value) {
    return OptimizerOptions_GlobalJitLevel_Name(value);
  }
  static inline bool GlobalJitLevel_Parse(const ::std::string& name,
      GlobalJitLevel* value) {
    return OptimizerOptions_GlobalJitLevel_Parse(name, value);
  }

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

  // bool do_common_subexpression_elimination = 1;
  void clear_do_common_subexpression_elimination();
  static const int kDoCommonSubexpressionEliminationFieldNumber = 1;
  bool do_common_subexpression_elimination() const;
  void set_do_common_subexpression_elimination(bool value);

  // bool do_constant_folding = 2;
  void clear_do_constant_folding();
  static const int kDoConstantFoldingFieldNumber = 2;
  bool do_constant_folding() const;
  void set_do_constant_folding(bool value);

  // bool do_function_inlining = 4;
  void clear_do_function_inlining();
  static const int kDoFunctionInliningFieldNumber = 4;
  bool do_function_inlining() const;
  void set_do_function_inlining(bool value);

  // .tensorflow.OptimizerOptions.Level opt_level = 3;
  void clear_opt_level();
  static const int kOptLevelFieldNumber = 3;
  ::tensorflow::OptimizerOptions_Level opt_level() const;
  void set_opt_level(::tensorflow::OptimizerOptions_Level value);

  // .tensorflow.OptimizerOptions.GlobalJitLevel global_jit_level = 5;
  void clear_global_jit_level();
  static const int kGlobalJitLevelFieldNumber = 5;
  ::tensorflow::OptimizerOptions_GlobalJitLevel global_jit_level() const;
  void set_global_jit_level(::tensorflow::OptimizerOptions_GlobalJitLevel value);

  // @@protoc_insertion_point(class_scope:tensorflow.OptimizerOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool do_common_subexpression_elimination_;
  bool do_constant_folding_;
  bool do_function_inlining_;
  int opt_level_;
  int global_jit_level_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class GraphOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphOptions) */ {
 public:
  GraphOptions();
  virtual ~GraphOptions();

  GraphOptions(const GraphOptions& from);

  inline GraphOptions& operator=(const GraphOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  GraphOptions(GraphOptions&& from) noexcept
    : GraphOptions() {
    *this = ::std::move(from);
  }

  inline GraphOptions& operator=(GraphOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GraphOptions& default_instance();

  static inline const GraphOptions* internal_default_instance() {
    return reinterpret_cast<const GraphOptions*>(
               &_GraphOptions_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  void UnsafeArenaSwap(GraphOptions* other);
  void Swap(GraphOptions* other);
  friend void swap(GraphOptions& a, GraphOptions& b) {
    a.Swap(&b);
  }

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

  inline GraphOptions* New() const PROTOBUF_FINAL { return New(NULL); }

  GraphOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const GraphOptions& from);
  void MergeFrom(const GraphOptions& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(GraphOptions* other);
  protected:
  explicit GraphOptions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // .tensorflow.OptimizerOptions optimizer_options = 3;
  bool has_optimizer_options() const;
  void clear_optimizer_options();
  static const int kOptimizerOptionsFieldNumber = 3;
  private:
  void _slow_mutable_optimizer_options();
  void _slow_set_allocated_optimizer_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::OptimizerOptions** optimizer_options);
  ::tensorflow::OptimizerOptions* _slow_release_optimizer_options();
  public:
  const ::tensorflow::OptimizerOptions& optimizer_options() const;
  ::tensorflow::OptimizerOptions* mutable_optimizer_options();
  ::tensorflow::OptimizerOptions* release_optimizer_options();
  void set_allocated_optimizer_options(::tensorflow::OptimizerOptions* optimizer_options);
  ::tensorflow::OptimizerOptions* unsafe_arena_release_optimizer_options();
  void unsafe_arena_set_allocated_optimizer_options(
      ::tensorflow::OptimizerOptions* optimizer_options);

  // .tensorflow.RewriterConfig rewrite_options = 10;
  bool has_rewrite_options() const;
  void clear_rewrite_options();
  static const int kRewriteOptionsFieldNumber = 10;
  private:
  void _slow_mutable_rewrite_options();
  void _slow_set_allocated_rewrite_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::RewriterConfig** rewrite_options);
  ::tensorflow::RewriterConfig* _slow_release_rewrite_options();
  public:
  const ::tensorflow::RewriterConfig& rewrite_options() const;
  ::tensorflow::RewriterConfig* mutable_rewrite_options();
  ::tensorflow::RewriterConfig* release_rewrite_options();
  void set_allocated_rewrite_options(::tensorflow::RewriterConfig* rewrite_options);
  ::tensorflow::RewriterConfig* unsafe_arena_release_rewrite_options();
  void unsafe_arena_set_allocated_rewrite_options(
      ::tensorflow::RewriterConfig* rewrite_options);

  // int64 build_cost_model = 4;
  void clear_build_cost_model();
  static const int kBuildCostModelFieldNumber = 4;
  ::google::protobuf::int64 build_cost_model() const;
  void set_build_cost_model(::google::protobuf::int64 value);

  // bool enable_recv_scheduling = 2;
  void clear_enable_recv_scheduling();
  static const int kEnableRecvSchedulingFieldNumber = 2;
  bool enable_recv_scheduling() const;
  void set_enable_recv_scheduling(bool value);

  // bool infer_shapes = 5;
  void clear_infer_shapes();
  static const int kInferShapesFieldNumber = 5;
  bool infer_shapes() const;
  void set_infer_shapes(bool value);

  // bool place_pruned_graph = 6;
  void clear_place_pruned_graph();
  static const int kPlacePrunedGraphFieldNumber = 6;
  bool place_pruned_graph() const;
  void set_place_pruned_graph(bool value);

  // bool enable_bfloat16_sendrecv = 7;
  void clear_enable_bfloat16_sendrecv();
  static const int kEnableBfloat16SendrecvFieldNumber = 7;
  bool enable_bfloat16_sendrecv() const;
  void set_enable_bfloat16_sendrecv(bool value);

  // int32 timeline_step = 8;
  void clear_timeline_step();
  static const int kTimelineStepFieldNumber = 8;
  ::google::protobuf::int32 timeline_step() const;
  void set_timeline_step(::google::protobuf::int32 value);

  // int64 build_cost_model_after = 9;
  void clear_build_cost_model_after();
  static const int kBuildCostModelAfterFieldNumber = 9;
  ::google::protobuf::int64 build_cost_model_after() const;
  void set_build_cost_model_after(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:tensorflow.GraphOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::OptimizerOptions* optimizer_options_;
  ::tensorflow::RewriterConfig* rewrite_options_;
  ::google::protobuf::int64 build_cost_model_;
  bool enable_recv_scheduling_;
  bool infer_shapes_;
  bool place_pruned_graph_;
  bool enable_bfloat16_sendrecv_;
  ::google::protobuf::int32 timeline_step_;
  ::google::protobuf::int64 build_cost_model_after_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ThreadPoolOptionProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.ThreadPoolOptionProto) */ {
 public:
  ThreadPoolOptionProto();
  virtual ~ThreadPoolOptionProto();

  ThreadPoolOptionProto(const ThreadPoolOptionProto& from);

  inline ThreadPoolOptionProto& operator=(const ThreadPoolOptionProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ThreadPoolOptionProto(ThreadPoolOptionProto&& from) noexcept
    : ThreadPoolOptionProto() {
    *this = ::std::move(from);
  }

  inline ThreadPoolOptionProto& operator=(ThreadPoolOptionProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ThreadPoolOptionProto& default_instance();

  static inline const ThreadPoolOptionProto* internal_default_instance() {
    return reinterpret_cast<const ThreadPoolOptionProto*>(
               &_ThreadPoolOptionProto_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  void UnsafeArenaSwap(ThreadPoolOptionProto* other);
  void Swap(ThreadPoolOptionProto* other);
  friend void swap(ThreadPoolOptionProto& a, ThreadPoolOptionProto& b) {
    a.Swap(&b);
  }

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

  inline ThreadPoolOptionProto* New() const PROTOBUF_FINAL { return New(NULL); }

  ThreadPoolOptionProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ThreadPoolOptionProto& from);
  void MergeFrom(const ThreadPoolOptionProto& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ThreadPoolOptionProto* other);
  protected:
  explicit ThreadPoolOptionProto(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // string global_name = 2;
  void clear_global_name();
  static const int kGlobalNameFieldNumber = 2;
  const ::std::string& global_name() const;
  void set_global_name(const ::std::string& value);
  #if LANG_CXX11
  void set_global_name(::std::string&& value);
  #endif
  void set_global_name(const char* value);
  void set_global_name(const char* value, size_t size);
  ::std::string* mutable_global_name();
  ::std::string* release_global_name();
  void set_allocated_global_name(::std::string* global_name);
  ::std::string* unsafe_arena_release_global_name();
  void unsafe_arena_set_allocated_global_name(
      ::std::string* global_name);

  // int32 num_threads = 1;
  void clear_num_threads();
  static const int kNumThreadsFieldNumber = 1;
  ::google::protobuf::int32 num_threads() const;
  void set_num_threads(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:tensorflow.ThreadPoolOptionProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr global_name_;
  ::google::protobuf::int32 num_threads_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RPCOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.RPCOptions) */ {
 public:
  RPCOptions();
  virtual ~RPCOptions();

  RPCOptions(const RPCOptions& from);

  inline RPCOptions& operator=(const RPCOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RPCOptions(RPCOptions&& from) noexcept
    : RPCOptions() {
    *this = ::std::move(from);
  }

  inline RPCOptions& operator=(RPCOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RPCOptions& default_instance();

  static inline const RPCOptions* internal_default_instance() {
    return reinterpret_cast<const RPCOptions*>(
               &_RPCOptions_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  void UnsafeArenaSwap(RPCOptions* other);
  void Swap(RPCOptions* other);
  friend void swap(RPCOptions& a, RPCOptions& b) {
    a.Swap(&b);
  }

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

  inline RPCOptions* New() const PROTOBUF_FINAL { return New(NULL); }

  RPCOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const RPCOptions& from);
  void MergeFrom(const RPCOptions& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(RPCOptions* other);
  protected:
  explicit RPCOptions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // bool use_rpc_for_inprocess_master = 1;
  void clear_use_rpc_for_inprocess_master();
  static const int kUseRpcForInprocessMasterFieldNumber = 1;
  bool use_rpc_for_inprocess_master() const;
  void set_use_rpc_for_inprocess_master(bool value);

  // @@protoc_insertion_point(class_scope:tensorflow.RPCOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool use_rpc_for_inprocess_master_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------


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

class ConfigProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.ConfigProto) */ {
 public:
  ConfigProto();
  virtual ~ConfigProto();

  ConfigProto(const ConfigProto& from);

  inline ConfigProto& operator=(const ConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ConfigProto(ConfigProto&& from) noexcept
    : ConfigProto() {
    *this = ::std::move(from);
  }

  inline ConfigProto& operator=(ConfigProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ConfigProto& default_instance();

  static inline const ConfigProto* internal_default_instance() {
    return reinterpret_cast<const ConfigProto*>(
               &_ConfigProto_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

  void UnsafeArenaSwap(ConfigProto* other);
  void Swap(ConfigProto* other);
  friend void swap(ConfigProto& a, ConfigProto& b) {
    a.Swap(&b);
  }

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

  inline ConfigProto* New() const PROTOBUF_FINAL { return New(NULL); }

  ConfigProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ConfigProto& from);
  void MergeFrom(const ConfigProto& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ConfigProto* other);
  protected:
  explicit ConfigProto(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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


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

  // map<string, int32> device_count = 1;
  int device_count_size() const;
  void clear_device_count();
  static const int kDeviceCountFieldNumber = 1;
  const ::google::protobuf::Map< ::std::string, ::google::protobuf::int32 >&
      device_count() const;
  ::google::protobuf::Map< ::std::string, ::google::protobuf::int32 >*
      mutable_device_count();

  // repeated string device_filters = 4;
  int device_filters_size() const;
  void clear_device_filters();
  static const int kDeviceFiltersFieldNumber = 4;
  const ::std::string& device_filters(int index) const;
  ::std::string* mutable_device_filters(int index);
  void set_device_filters(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_device_filters(int index, ::std::string&& value);
  #endif
  void set_device_filters(int index, const char* value);
  void set_device_filters(int index, const char* value, size_t size);
  ::std::string* add_device_filters();
  void add_device_filters(const ::std::string& value);
  #if LANG_CXX11
  void add_device_filters(::std::string&& value);
  #endif
  void add_device_filters(const char* value);
  void add_device_filters(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& device_filters() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_device_filters();

  // repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
  int session_inter_op_thread_pool_size() const;
  void clear_session_inter_op_thread_pool();
  static const int kSessionInterOpThreadPoolFieldNumber = 12;
  const ::tensorflow::ThreadPoolOptionProto& session_inter_op_thread_pool(int index) const;
  ::tensorflow::ThreadPoolOptionProto* mutable_session_inter_op_thread_pool(int index);
  ::tensorflow::ThreadPoolOptionProto* add_session_inter_op_thread_pool();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto >*
      mutable_session_inter_op_thread_pool();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto >&
      session_inter_op_thread_pool() const;

  // .tensorflow.GPUOptions gpu_options = 6;
  bool has_gpu_options() const;
  void clear_gpu_options();
  static const int kGpuOptionsFieldNumber = 6;
  private:
  void _slow_mutable_gpu_options();
  void _slow_set_allocated_gpu_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::GPUOptions** gpu_options);
  ::tensorflow::GPUOptions* _slow_release_gpu_options();
  public:
  const ::tensorflow::GPUOptions& gpu_options() const;
  ::tensorflow::GPUOptions* mutable_gpu_options();
  ::tensorflow::GPUOptions* release_gpu_options();
  void set_allocated_gpu_options(::tensorflow::GPUOptions* gpu_options);
  ::tensorflow::GPUOptions* unsafe_arena_release_gpu_options();
  void unsafe_arena_set_allocated_gpu_options(
      ::tensorflow::GPUOptions* gpu_options);

  // .tensorflow.GraphOptions graph_options = 10;
  bool has_graph_options() const;
  void clear_graph_options();
  static const int kGraphOptionsFieldNumber = 10;
  private:
  void _slow_mutable_graph_options();
  void _slow_set_allocated_graph_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::GraphOptions** graph_options);
  ::tensorflow::GraphOptions* _slow_release_graph_options();
  public:
  const ::tensorflow::GraphOptions& graph_options() const;
  ::tensorflow::GraphOptions* mutable_graph_options();
  ::tensorflow::GraphOptions* release_graph_options();
  void set_allocated_graph_options(::tensorflow::GraphOptions* graph_options);
  ::tensorflow::GraphOptions* unsafe_arena_release_graph_options();
  void unsafe_arena_set_allocated_graph_options(
      ::tensorflow::GraphOptions* graph_options);

  // .tensorflow.RPCOptions rpc_options = 13;
  bool has_rpc_options() const;
  void clear_rpc_options();
  static const int kRpcOptionsFieldNumber = 13;
  private:
  void _slow_mutable_rpc_options();
  void _slow_set_allocated_rpc_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::RPCOptions** rpc_options);
  ::tensorflow::RPCOptions* _slow_release_rpc_options();
  public:
  const ::tensorflow::RPCOptions& rpc_options() const;
  ::tensorflow::RPCOptions* mutable_rpc_options();
  ::tensorflow::RPCOptions* release_rpc_options();
  void set_allocated_rpc_options(::tensorflow::RPCOptions* rpc_options);
  ::tensorflow::RPCOptions* unsafe_arena_release_rpc_options();
  void unsafe_arena_set_allocated_rpc_options(
      ::tensorflow::RPCOptions* rpc_options);

  // .tensorflow.ClusterDef cluster_def = 14;
  bool has_cluster_def() const;
  void clear_cluster_def();
  static const int kClusterDefFieldNumber = 14;
  private:
  void _slow_mutable_cluster_def();
  void _slow_set_allocated_cluster_def(
      ::google::protobuf::Arena* message_arena, ::tensorflow::ClusterDef** cluster_def);
  ::tensorflow::ClusterDef* _slow_release_cluster_def();
  public:
  const ::tensorflow::ClusterDef& cluster_def() const;
  ::tensorflow::ClusterDef* mutable_cluster_def();
  ::tensorflow::ClusterDef* release_cluster_def();
  void set_allocated_cluster_def(::tensorflow::ClusterDef* cluster_def);
  ::tensorflow::ClusterDef* unsafe_arena_release_cluster_def();
  void unsafe_arena_set_allocated_cluster_def(
      ::tensorflow::ClusterDef* cluster_def);

  // int32 intra_op_parallelism_threads = 2;
  void clear_intra_op_parallelism_threads();
  static const int kIntraOpParallelismThreadsFieldNumber = 2;
  ::google::protobuf::int32 intra_op_parallelism_threads() const;
  void set_intra_op_parallelism_threads(::google::protobuf::int32 value);

  // int32 placement_period = 3;
  void clear_placement_period();
  static const int kPlacementPeriodFieldNumber = 3;
  ::google::protobuf::int32 placement_period() const;
  void set_placement_period(::google::protobuf::int32 value);

  // int32 inter_op_parallelism_threads = 5;
  void clear_inter_op_parallelism_threads();
  static const int kInterOpParallelismThreadsFieldNumber = 5;
  ::google::protobuf::int32 inter_op_parallelism_threads() const;
  void set_inter_op_parallelism_threads(::google::protobuf::int32 value);

  // bool use_per_session_threads = 9;
  void clear_use_per_session_threads();
  static const int kUsePerSessionThreadsFieldNumber = 9;
  bool use_per_session_threads() const;
  void set_use_per_session_threads(bool value);

  // bool allow_soft_placement = 7;
  void clear_allow_soft_placement();
  static const int kAllowSoftPlacementFieldNumber = 7;
  bool allow_soft_placement() const;
  void set_allow_soft_placement(bool value);

  // bool log_device_placement = 8;
  void clear_log_device_placement();
  static const int kLogDevicePlacementFieldNumber = 8;
  bool log_device_placement() const;
  void set_log_device_placement(bool value);

  // int64 operation_timeout_in_ms = 11;
  void clear_operation_timeout_in_ms();
  static const int kOperationTimeoutInMsFieldNumber = 11;
  ::google::protobuf::int64 operation_timeout_in_ms() const;
  void set_operation_timeout_in_ms(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:tensorflow.ConfigProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  public:
  class ConfigProto_DeviceCountEntry : public ::google::protobuf::internal::MapEntry<ConfigProto_DeviceCountEntry, 
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 > {
  public:
    typedef ::google::protobuf::internal::MapEntry<ConfigProto_DeviceCountEntry, 
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 > SuperType;
    ConfigProto_DeviceCountEntry();
    ConfigProto_DeviceCountEntry(::google::protobuf::Arena* arena);
    void MergeFrom(const ::google::protobuf::Message& other) PROTOBUF_FINAL;
    void MergeFrom(const ConfigProto_DeviceCountEntry& other);
    static const Message* internal_default_instance() { return reinterpret_cast<const Message*>(&_ConfigProto_DeviceCountEntry_default_instance_); }
    ::google::protobuf::Metadata GetMetadata() const;
  };
  private:
  ::google::protobuf::internal::MapField<
      ConfigProto_DeviceCountEntry,
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 > device_count_;
  private:
  ::google::protobuf::RepeatedPtrField< ::std::string> device_filters_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto > session_inter_op_thread_pool_;
  ::tensorflow::GPUOptions* gpu_options_;
  ::tensorflow::GraphOptions* graph_options_;
  ::tensorflow::RPCOptions* rpc_options_;
  ::tensorflow::ClusterDef* cluster_def_;
  ::google::protobuf::int32 intra_op_parallelism_threads_;
  ::google::protobuf::int32 placement_period_;
  ::google::protobuf::int32 inter_op_parallelism_threads_;
  bool use_per_session_threads_;
  bool allow_soft_placement_;
  bool log_device_placement_;
  ::google::protobuf::int64 operation_timeout_in_ms_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RunOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.RunOptions) */ {
 public:
  RunOptions();
  virtual ~RunOptions();

  RunOptions(const RunOptions& from);

  inline RunOptions& operator=(const RunOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RunOptions(RunOptions&& from) noexcept
    : RunOptions() {
    *this = ::std::move(from);
  }

  inline RunOptions& operator=(RunOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunOptions& default_instance();

  static inline const RunOptions* internal_default_instance() {
    return reinterpret_cast<const RunOptions*>(
               &_RunOptions_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    7;

  void UnsafeArenaSwap(RunOptions* other);
  void Swap(RunOptions* other);
  friend void swap(RunOptions& a, RunOptions& b) {
    a.Swap(&b);
  }

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

  inline RunOptions* New() const PROTOBUF_FINAL { return New(NULL); }

  RunOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const RunOptions& from);
  void MergeFrom(const RunOptions& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(RunOptions* other);
  protected:
  explicit RunOptions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

  typedef RunOptions_TraceLevel TraceLevel;
  static const TraceLevel NO_TRACE =
    RunOptions_TraceLevel_NO_TRACE;
  static const TraceLevel SOFTWARE_TRACE =
    RunOptions_TraceLevel_SOFTWARE_TRACE;
  static const TraceLevel HARDWARE_TRACE =
    RunOptions_TraceLevel_HARDWARE_TRACE;
  static const TraceLevel FULL_TRACE =
    RunOptions_TraceLevel_FULL_TRACE;
  static inline bool TraceLevel_IsValid(int value) {
    return RunOptions_TraceLevel_IsValid(value);
  }
  static const TraceLevel TraceLevel_MIN =
    RunOptions_TraceLevel_TraceLevel_MIN;
  static const TraceLevel TraceLevel_MAX =
    RunOptions_TraceLevel_TraceLevel_MAX;
  static const int TraceLevel_ARRAYSIZE =
    RunOptions_TraceLevel_TraceLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TraceLevel_descriptor() {
    return RunOptions_TraceLevel_descriptor();
  }
  static inline const ::std::string& TraceLevel_Name(TraceLevel value) {
    return RunOptions_TraceLevel_Name(value);
  }
  static inline bool TraceLevel_Parse(const ::std::string& name,
      TraceLevel* value) {
    return RunOptions_TraceLevel_Parse(name, value);
  }

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

  // .tensorflow.DebugOptions debug_options = 6;
  bool has_debug_options() const;
  void clear_debug_options();
  static const int kDebugOptionsFieldNumber = 6;
  private:
  void _slow_mutable_debug_options();
  void _slow_set_allocated_debug_options(
      ::google::protobuf::Arena* message_arena, ::tensorflow::DebugOptions** debug_options);
  ::tensorflow::DebugOptions* _slow_release_debug_options();
  public:
  const ::tensorflow::DebugOptions& debug_options() const;
  ::tensorflow::DebugOptions* mutable_debug_options();
  ::tensorflow::DebugOptions* release_debug_options();
  void set_allocated_debug_options(::tensorflow::DebugOptions* debug_options);
  ::tensorflow::DebugOptions* unsafe_arena_release_debug_options();
  void unsafe_arena_set_allocated_debug_options(
      ::tensorflow::DebugOptions* debug_options);

  // int64 timeout_in_ms = 2;
  void clear_timeout_in_ms();
  static const int kTimeoutInMsFieldNumber = 2;
  ::google::protobuf::int64 timeout_in_ms() const;
  void set_timeout_in_ms(::google::protobuf::int64 value);

  // .tensorflow.RunOptions.TraceLevel trace_level = 1;
  void clear_trace_level();
  static const int kTraceLevelFieldNumber = 1;
  ::tensorflow::RunOptions_TraceLevel trace_level() const;
  void set_trace_level(::tensorflow::RunOptions_TraceLevel value);

  // int32 inter_op_thread_pool = 3;
  void clear_inter_op_thread_pool();
  static const int kInterOpThreadPoolFieldNumber = 3;
  ::google::protobuf::int32 inter_op_thread_pool() const;
  void set_inter_op_thread_pool(::google::protobuf::int32 value);

  // bool output_partition_graphs = 5;
  void clear_output_partition_graphs();
  static const int kOutputPartitionGraphsFieldNumber = 5;
  bool output_partition_graphs() const;
  void set_output_partition_graphs(bool value);

  // @@protoc_insertion_point(class_scope:tensorflow.RunOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::DebugOptions* debug_options_;
  ::google::protobuf::int64 timeout_in_ms_;
  int trace_level_;
  ::google::protobuf::int32 inter_op_thread_pool_;
  bool output_partition_graphs_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RunMetadata : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.RunMetadata) */ {
 public:
  RunMetadata();
  virtual ~RunMetadata();

  RunMetadata(const RunMetadata& from);

  inline RunMetadata& operator=(const RunMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RunMetadata(RunMetadata&& from) noexcept
    : RunMetadata() {
    *this = ::std::move(from);
  }

  inline RunMetadata& operator=(RunMetadata&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunMetadata& default_instance();

  static inline const RunMetadata* internal_default_instance() {
    return reinterpret_cast<const RunMetadata*>(
               &_RunMetadata_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    8;

  void UnsafeArenaSwap(RunMetadata* other);
  void Swap(RunMetadata* other);
  friend void swap(RunMetadata& a, RunMetadata& b) {
    a.Swap(&b);
  }

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

  inline RunMetadata* New() const PROTOBUF_FINAL { return New(NULL); }

  RunMetadata* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const RunMetadata& from);
  void MergeFrom(const RunMetadata& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(RunMetadata* other);
  protected:
  explicit RunMetadata(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .tensorflow.GraphDef partition_graphs = 3;
  int partition_graphs_size() const;
  void clear_partition_graphs();
  static const int kPartitionGraphsFieldNumber = 3;
  const ::tensorflow::GraphDef& partition_graphs(int index) const;
  ::tensorflow::GraphDef* mutable_partition_graphs(int index);
  ::tensorflow::GraphDef* add_partition_graphs();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >*
      mutable_partition_graphs();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >&
      partition_graphs() const;

  // .tensorflow.StepStats step_stats = 1;
  bool has_step_stats() const;
  void clear_step_stats();
  static const int kStepStatsFieldNumber = 1;
  private:
  void _slow_mutable_step_stats();
  void _slow_set_allocated_step_stats(
      ::google::protobuf::Arena* message_arena, ::tensorflow::StepStats** step_stats);
  ::tensorflow::StepStats* _slow_release_step_stats();
  public:
  const ::tensorflow::StepStats& step_stats() const;
  ::tensorflow::StepStats* mutable_step_stats();
  ::tensorflow::StepStats* release_step_stats();
  void set_allocated_step_stats(::tensorflow::StepStats* step_stats);
  ::tensorflow::StepStats* unsafe_arena_release_step_stats();
  void unsafe_arena_set_allocated_step_stats(
      ::tensorflow::StepStats* step_stats);

  // .tensorflow.CostGraphDef cost_graph = 2;
  bool has_cost_graph() const;
  void clear_cost_graph();
  static const int kCostGraphFieldNumber = 2;
  private:
  void _slow_mutable_cost_graph();
  void _slow_set_allocated_cost_graph(
      ::google::protobuf::Arena* message_arena, ::tensorflow::CostGraphDef** cost_graph);
  ::tensorflow::CostGraphDef* _slow_release_cost_graph();
  public:
  const ::tensorflow::CostGraphDef& cost_graph() const;
  ::tensorflow::CostGraphDef* mutable_cost_graph();
  ::tensorflow::CostGraphDef* release_cost_graph();
  void set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph);
  ::tensorflow::CostGraphDef* unsafe_arena_release_cost_graph();
  void unsafe_arena_set_allocated_cost_graph(
      ::tensorflow::CostGraphDef* cost_graph);

  // @@protoc_insertion_point(class_scope:tensorflow.RunMetadata)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef > partition_graphs_;
  ::tensorflow::StepStats* step_stats_;
  ::tensorflow::CostGraphDef* cost_graph_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// ===================================================================


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// GPUOptions

// double per_process_gpu_memory_fraction = 1;
inline void GPUOptions::clear_per_process_gpu_memory_fraction() {
  per_process_gpu_memory_fraction_ = 0;
}
inline double GPUOptions::per_process_gpu_memory_fraction() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.per_process_gpu_memory_fraction)
  return per_process_gpu_memory_fraction_;
}
inline void GPUOptions::set_per_process_gpu_memory_fraction(double value) {
  
  per_process_gpu_memory_fraction_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.per_process_gpu_memory_fraction)
}

// string allocator_type = 2;
inline void GPUOptions::clear_allocator_type() {
  allocator_type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& GPUOptions::allocator_type() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.allocator_type)
  return allocator_type_.Get();
}
inline void GPUOptions::set_allocator_type(const ::std::string& value) {
  
  allocator_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.allocator_type)
}
#if LANG_CXX11
inline void GPUOptions::set_allocator_type(::std::string&& value) {
  
  allocator_type_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.GPUOptions.allocator_type)
}
#endif
inline void GPUOptions::set_allocator_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  allocator_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.GPUOptions.allocator_type)
}
inline void GPUOptions::set_allocator_type(const char* value,
    size_t size) {
  
  allocator_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUOptions.allocator_type)
}
inline ::std::string* GPUOptions::mutable_allocator_type() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.allocator_type)
  return allocator_type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::release_allocator_type() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUOptions.allocator_type)
  
  return allocator_type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::unsafe_arena_release_allocator_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUOptions.allocator_type)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return allocator_type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void GPUOptions::set_allocated_allocator_type(::std::string* allocator_type) {
  if (allocator_type != NULL) {
    
  } else {
    
  }
  allocator_type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), allocator_type,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUOptions.allocator_type)
}
inline void GPUOptions::unsafe_arena_set_allocated_allocator_type(
    ::std::string* allocator_type) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (allocator_type != NULL) {
    
  } else {
    
  }
  allocator_type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      allocator_type, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUOptions.allocator_type)
}

// int64 deferred_deletion_bytes = 3;
inline void GPUOptions::clear_deferred_deletion_bytes() {
  deferred_deletion_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 GPUOptions::deferred_deletion_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.deferred_deletion_bytes)
  return deferred_deletion_bytes_;
}
inline void GPUOptions::set_deferred_deletion_bytes(::google::protobuf::int64 value) {
  
  deferred_deletion_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.deferred_deletion_bytes)
}

// bool allow_growth = 4;
inline void GPUOptions::clear_allow_growth() {
  allow_growth_ = false;
}
inline bool GPUOptions::allow_growth() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.allow_growth)
  return allow_growth_;
}
inline void GPUOptions::set_allow_growth(bool value) {
  
  allow_growth_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.allow_growth)
}

// string visible_device_list = 5;
inline void GPUOptions::clear_visible_device_list() {
  visible_device_list_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& GPUOptions::visible_device_list() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.visible_device_list)
  return visible_device_list_.Get();
}
inline void GPUOptions::set_visible_device_list(const ::std::string& value) {
  
  visible_device_list_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.visible_device_list)
}
#if LANG_CXX11
inline void GPUOptions::set_visible_device_list(::std::string&& value) {
  
  visible_device_list_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.GPUOptions.visible_device_list)
}
#endif
inline void GPUOptions::set_visible_device_list(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  visible_device_list_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.GPUOptions.visible_device_list)
}
inline void GPUOptions::set_visible_device_list(const char* value,
    size_t size) {
  
  visible_device_list_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUOptions.visible_device_list)
}
inline ::std::string* GPUOptions::mutable_visible_device_list() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.visible_device_list)
  return visible_device_list_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::release_visible_device_list() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUOptions.visible_device_list)
  
  return visible_device_list_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::unsafe_arena_release_visible_device_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUOptions.visible_device_list)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return visible_device_list_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void GPUOptions::set_allocated_visible_device_list(::std::string* visible_device_list) {
  if (visible_device_list != NULL) {
    
  } else {
    
  }
  visible_device_list_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), visible_device_list,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUOptions.visible_device_list)
}
inline void GPUOptions::unsafe_arena_set_allocated_visible_device_list(
    ::std::string* visible_device_list) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (visible_device_list != NULL) {
    
  } else {
    
  }
  visible_device_list_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      visible_device_list, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUOptions.visible_device_list)
}

// int32 polling_active_delay_usecs = 6;
inline void GPUOptions::clear_polling_active_delay_usecs() {
  polling_active_delay_usecs_ = 0;
}
inline ::google::protobuf::int32 GPUOptions::polling_active_delay_usecs() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.polling_active_delay_usecs)
  return polling_active_delay_usecs_;
}
inline void GPUOptions::set_polling_active_delay_usecs(::google::protobuf::int32 value) {
  
  polling_active_delay_usecs_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.polling_active_delay_usecs)
}

// int32 polling_inactive_delay_msecs = 7;
inline void GPUOptions::clear_polling_inactive_delay_msecs() {
  polling_inactive_delay_msecs_ = 0;
}
inline ::google::protobuf::int32 GPUOptions::polling_inactive_delay_msecs() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.polling_inactive_delay_msecs)
  return polling_inactive_delay_msecs_;
}
inline void GPUOptions::set_polling_inactive_delay_msecs(::google::protobuf::int32 value) {
  
  polling_inactive_delay_msecs_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.polling_inactive_delay_msecs)
}

// bool force_gpu_compatible = 8;
inline void GPUOptions::clear_force_gpu_compatible() {
  force_gpu_compatible_ = false;
}
inline bool GPUOptions::force_gpu_compatible() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.force_gpu_compatible)
  return force_gpu_compatible_;
}
inline void GPUOptions::set_force_gpu_compatible(bool value) {
  
  force_gpu_compatible_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.force_gpu_compatible)
}

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

// OptimizerOptions

// bool do_common_subexpression_elimination = 1;
inline void OptimizerOptions::clear_do_common_subexpression_elimination() {
  do_common_subexpression_elimination_ = false;
}
inline bool OptimizerOptions::do_common_subexpression_elimination() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.do_common_subexpression_elimination)
  return do_common_subexpression_elimination_;
}
inline void OptimizerOptions::set_do_common_subexpression_elimination(bool value) {
  
  do_common_subexpression_elimination_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.do_common_subexpression_elimination)
}

// bool do_constant_folding = 2;
inline void OptimizerOptions::clear_do_constant_folding() {
  do_constant_folding_ = false;
}
inline bool OptimizerOptions::do_constant_folding() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.do_constant_folding)
  return do_constant_folding_;
}
inline void OptimizerOptions::set_do_constant_folding(bool value) {
  
  do_constant_folding_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.do_constant_folding)
}

// bool do_function_inlining = 4;
inline void OptimizerOptions::clear_do_function_inlining() {
  do_function_inlining_ = false;
}
inline bool OptimizerOptions::do_function_inlining() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.do_function_inlining)
  return do_function_inlining_;
}
inline void OptimizerOptions::set_do_function_inlining(bool value) {
  
  do_function_inlining_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.do_function_inlining)
}

// .tensorflow.OptimizerOptions.Level opt_level = 3;
inline void OptimizerOptions::clear_opt_level() {
  opt_level_ = 0;
}
inline ::tensorflow::OptimizerOptions_Level OptimizerOptions::opt_level() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.opt_level)
  return static_cast< ::tensorflow::OptimizerOptions_Level >(opt_level_);
}
inline void OptimizerOptions::set_opt_level(::tensorflow::OptimizerOptions_Level value) {
  
  opt_level_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.opt_level)
}

// .tensorflow.OptimizerOptions.GlobalJitLevel global_jit_level = 5;
inline void OptimizerOptions::clear_global_jit_level() {
  global_jit_level_ = 0;
}
inline ::tensorflow::OptimizerOptions_GlobalJitLevel OptimizerOptions::global_jit_level() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.global_jit_level)
  return static_cast< ::tensorflow::OptimizerOptions_GlobalJitLevel >(global_jit_level_);
}
inline void OptimizerOptions::set_global_jit_level(::tensorflow::OptimizerOptions_GlobalJitLevel value) {
  
  global_jit_level_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.global_jit_level)
}

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

// GraphOptions

// bool enable_recv_scheduling = 2;
inline void GraphOptions::clear_enable_recv_scheduling() {
  enable_recv_scheduling_ = false;
}
inline bool GraphOptions::enable_recv_scheduling() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.enable_recv_scheduling)
  return enable_recv_scheduling_;
}
inline void GraphOptions::set_enable_recv_scheduling(bool value) {
  
  enable_recv_scheduling_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.enable_recv_scheduling)
}

// .tensorflow.OptimizerOptions optimizer_options = 3;
inline bool GraphOptions::has_optimizer_options() const {
  return this != internal_default_instance() && optimizer_options_ != NULL;
}
inline void GraphOptions::clear_optimizer_options() {
  if (GetArenaNoVirtual() == NULL && optimizer_options_ != NULL) delete optimizer_options_;
  optimizer_options_ = NULL;
}
inline const ::tensorflow::OptimizerOptions& GraphOptions::optimizer_options() const {
  const ::tensorflow::OptimizerOptions* p = optimizer_options_;
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.optimizer_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::OptimizerOptions*>(
      &::tensorflow::_OptimizerOptions_default_instance_);
}
inline ::tensorflow::OptimizerOptions* GraphOptions::mutable_optimizer_options() {
  
  if (optimizer_options_ == NULL) {
    _slow_mutable_optimizer_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.GraphOptions.optimizer_options)
  return optimizer_options_;
}
inline ::tensorflow::OptimizerOptions* GraphOptions::release_optimizer_options() {
  // @@protoc_insertion_point(field_release:tensorflow.GraphOptions.optimizer_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_optimizer_options();
  } else {
    ::tensorflow::OptimizerOptions* temp = optimizer_options_;
    optimizer_options_ = NULL;
    return temp;
  }
}
inline  void GraphOptions::set_allocated_optimizer_options(::tensorflow::OptimizerOptions* optimizer_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optimizer_options_;
  }
  if (optimizer_options != NULL) {
    _slow_set_allocated_optimizer_options(message_arena, &optimizer_options);
  }
  optimizer_options_ = optimizer_options;
  if (optimizer_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOptions.optimizer_options)
}

// int64 build_cost_model = 4;
inline void GraphOptions::clear_build_cost_model() {
  build_cost_model_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 GraphOptions::build_cost_model() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.build_cost_model)
  return build_cost_model_;
}
inline void GraphOptions::set_build_cost_model(::google::protobuf::int64 value) {
  
  build_cost_model_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.build_cost_model)
}

// int64 build_cost_model_after = 9;
inline void GraphOptions::clear_build_cost_model_after() {
  build_cost_model_after_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 GraphOptions::build_cost_model_after() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.build_cost_model_after)
  return build_cost_model_after_;
}
inline void GraphOptions::set_build_cost_model_after(::google::protobuf::int64 value) {
  
  build_cost_model_after_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.build_cost_model_after)
}

// bool infer_shapes = 5;
inline void GraphOptions::clear_infer_shapes() {
  infer_shapes_ = false;
}
inline bool GraphOptions::infer_shapes() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.infer_shapes)
  return infer_shapes_;
}
inline void GraphOptions::set_infer_shapes(bool value) {
  
  infer_shapes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.infer_shapes)
}

// bool place_pruned_graph = 6;
inline void GraphOptions::clear_place_pruned_graph() {
  place_pruned_graph_ = false;
}
inline bool GraphOptions::place_pruned_graph() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.place_pruned_graph)
  return place_pruned_graph_;
}
inline void GraphOptions::set_place_pruned_graph(bool value) {
  
  place_pruned_graph_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.place_pruned_graph)
}

// bool enable_bfloat16_sendrecv = 7;
inline void GraphOptions::clear_enable_bfloat16_sendrecv() {
  enable_bfloat16_sendrecv_ = false;
}
inline bool GraphOptions::enable_bfloat16_sendrecv() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.enable_bfloat16_sendrecv)
  return enable_bfloat16_sendrecv_;
}
inline void GraphOptions::set_enable_bfloat16_sendrecv(bool value) {
  
  enable_bfloat16_sendrecv_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.enable_bfloat16_sendrecv)
}

// int32 timeline_step = 8;
inline void GraphOptions::clear_timeline_step() {
  timeline_step_ = 0;
}
inline ::google::protobuf::int32 GraphOptions::timeline_step() const {
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.timeline_step)
  return timeline_step_;
}
inline void GraphOptions::set_timeline_step(::google::protobuf::int32 value) {
  
  timeline_step_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GraphOptions.timeline_step)
}

// .tensorflow.RewriterConfig rewrite_options = 10;
inline bool GraphOptions::has_rewrite_options() const {
  return this != internal_default_instance() && rewrite_options_ != NULL;
}
inline void GraphOptions::clear_rewrite_options() {
  if (GetArenaNoVirtual() == NULL && rewrite_options_ != NULL) delete rewrite_options_;
  rewrite_options_ = NULL;
}
inline const ::tensorflow::RewriterConfig& GraphOptions::rewrite_options() const {
  const ::tensorflow::RewriterConfig* p = rewrite_options_;
  // @@protoc_insertion_point(field_get:tensorflow.GraphOptions.rewrite_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::RewriterConfig*>(
      &::tensorflow::_RewriterConfig_default_instance_);
}
inline ::tensorflow::RewriterConfig* GraphOptions::mutable_rewrite_options() {
  
  if (rewrite_options_ == NULL) {
    _slow_mutable_rewrite_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.GraphOptions.rewrite_options)
  return rewrite_options_;
}
inline ::tensorflow::RewriterConfig* GraphOptions::release_rewrite_options() {
  // @@protoc_insertion_point(field_release:tensorflow.GraphOptions.rewrite_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_rewrite_options();
  } else {
    ::tensorflow::RewriterConfig* temp = rewrite_options_;
    rewrite_options_ = NULL;
    return temp;
  }
}
inline  void GraphOptions::set_allocated_rewrite_options(::tensorflow::RewriterConfig* rewrite_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete rewrite_options_;
  }
  if (rewrite_options != NULL) {
    _slow_set_allocated_rewrite_options(message_arena, &rewrite_options);
  }
  rewrite_options_ = rewrite_options;
  if (rewrite_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOptions.rewrite_options)
}

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

// ThreadPoolOptionProto

// int32 num_threads = 1;
inline void ThreadPoolOptionProto::clear_num_threads() {
  num_threads_ = 0;
}
inline ::google::protobuf::int32 ThreadPoolOptionProto::num_threads() const {
  // @@protoc_insertion_point(field_get:tensorflow.ThreadPoolOptionProto.num_threads)
  return num_threads_;
}
inline void ThreadPoolOptionProto::set_num_threads(::google::protobuf::int32 value) {
  
  num_threads_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ThreadPoolOptionProto.num_threads)
}

// string global_name = 2;
inline void ThreadPoolOptionProto::clear_global_name() {
  global_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& ThreadPoolOptionProto::global_name() const {
  // @@protoc_insertion_point(field_get:tensorflow.ThreadPoolOptionProto.global_name)
  return global_name_.Get();
}
inline void ThreadPoolOptionProto::set_global_name(const ::std::string& value) {
  
  global_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.ThreadPoolOptionProto.global_name)
}
#if LANG_CXX11
inline void ThreadPoolOptionProto::set_global_name(::std::string&& value) {
  
  global_name_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.ThreadPoolOptionProto.global_name)
}
#endif
inline void ThreadPoolOptionProto::set_global_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  global_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.ThreadPoolOptionProto.global_name)
}
inline void ThreadPoolOptionProto::set_global_name(const char* value,
    size_t size) {
  
  global_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.ThreadPoolOptionProto.global_name)
}
inline ::std::string* ThreadPoolOptionProto::mutable_global_name() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.ThreadPoolOptionProto.global_name)
  return global_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* ThreadPoolOptionProto::release_global_name() {
  // @@protoc_insertion_point(field_release:tensorflow.ThreadPoolOptionProto.global_name)
  
  return global_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* ThreadPoolOptionProto::unsafe_arena_release_global_name() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ThreadPoolOptionProto.global_name)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return global_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void ThreadPoolOptionProto::set_allocated_global_name(::std::string* global_name) {
  if (global_name != NULL) {
    
  } else {
    
  }
  global_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), global_name,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ThreadPoolOptionProto.global_name)
}
inline void ThreadPoolOptionProto::unsafe_arena_set_allocated_global_name(
    ::std::string* global_name) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (global_name != NULL) {
    
  } else {
    
  }
  global_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      global_name, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ThreadPoolOptionProto.global_name)
}

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

// RPCOptions

// bool use_rpc_for_inprocess_master = 1;
inline void RPCOptions::clear_use_rpc_for_inprocess_master() {
  use_rpc_for_inprocess_master_ = false;
}
inline bool RPCOptions::use_rpc_for_inprocess_master() const {
  // @@protoc_insertion_point(field_get:tensorflow.RPCOptions.use_rpc_for_inprocess_master)
  return use_rpc_for_inprocess_master_;
}
inline void RPCOptions::set_use_rpc_for_inprocess_master(bool value) {
  
  use_rpc_for_inprocess_master_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RPCOptions.use_rpc_for_inprocess_master)
}

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

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

// ConfigProto

// map<string, int32> device_count = 1;
inline int ConfigProto::device_count_size() const {
  return device_count_.size();
}
inline void ConfigProto::clear_device_count() {
  device_count_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::google::protobuf::int32 >&
ConfigProto::device_count() const {
  // @@protoc_insertion_point(field_map:tensorflow.ConfigProto.device_count)
  return device_count_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::google::protobuf::int32 >*
ConfigProto::mutable_device_count() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.ConfigProto.device_count)
  return device_count_.MutableMap();
}

// int32 intra_op_parallelism_threads = 2;
inline void ConfigProto::clear_intra_op_parallelism_threads() {
  intra_op_parallelism_threads_ = 0;
}
inline ::google::protobuf::int32 ConfigProto::intra_op_parallelism_threads() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.intra_op_parallelism_threads)
  return intra_op_parallelism_threads_;
}
inline void ConfigProto::set_intra_op_parallelism_threads(::google::protobuf::int32 value) {
  
  intra_op_parallelism_threads_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.intra_op_parallelism_threads)
}

// int32 inter_op_parallelism_threads = 5;
inline void ConfigProto::clear_inter_op_parallelism_threads() {
  inter_op_parallelism_threads_ = 0;
}
inline ::google::protobuf::int32 ConfigProto::inter_op_parallelism_threads() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.inter_op_parallelism_threads)
  return inter_op_parallelism_threads_;
}
inline void ConfigProto::set_inter_op_parallelism_threads(::google::protobuf::int32 value) {
  
  inter_op_parallelism_threads_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.inter_op_parallelism_threads)
}

// bool use_per_session_threads = 9;
inline void ConfigProto::clear_use_per_session_threads() {
  use_per_session_threads_ = false;
}
inline bool ConfigProto::use_per_session_threads() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.use_per_session_threads)
  return use_per_session_threads_;
}
inline void ConfigProto::set_use_per_session_threads(bool value) {
  
  use_per_session_threads_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.use_per_session_threads)
}

// repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
inline int ConfigProto::session_inter_op_thread_pool_size() const {
  return session_inter_op_thread_pool_.size();
}
inline void ConfigProto::clear_session_inter_op_thread_pool() {
  session_inter_op_thread_pool_.Clear();
}
inline const ::tensorflow::ThreadPoolOptionProto& ConfigProto::session_inter_op_thread_pool(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.session_inter_op_thread_pool)
  return session_inter_op_thread_pool_.Get(index);
}
inline ::tensorflow::ThreadPoolOptionProto* ConfigProto::mutable_session_inter_op_thread_pool(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.session_inter_op_thread_pool)
  return session_inter_op_thread_pool_.Mutable(index);
}
inline ::tensorflow::ThreadPoolOptionProto* ConfigProto::add_session_inter_op_thread_pool() {
  // @@protoc_insertion_point(field_add:tensorflow.ConfigProto.session_inter_op_thread_pool)
  return session_inter_op_thread_pool_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto >*
ConfigProto::mutable_session_inter_op_thread_pool() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.ConfigProto.session_inter_op_thread_pool)
  return &session_inter_op_thread_pool_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto >&
ConfigProto::session_inter_op_thread_pool() const {
  // @@protoc_insertion_point(field_list:tensorflow.ConfigProto.session_inter_op_thread_pool)
  return session_inter_op_thread_pool_;
}

// int32 placement_period = 3;
inline void ConfigProto::clear_placement_period() {
  placement_period_ = 0;
}
inline ::google::protobuf::int32 ConfigProto::placement_period() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.placement_period)
  return placement_period_;
}
inline void ConfigProto::set_placement_period(::google::protobuf::int32 value) {
  
  placement_period_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.placement_period)
}

// repeated string device_filters = 4;
inline int ConfigProto::device_filters_size() const {
  return device_filters_.size();
}
inline void ConfigProto::clear_device_filters() {
  device_filters_.Clear();
}
inline const ::std::string& ConfigProto::device_filters(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.device_filters)
  return device_filters_.Get(index);
}
inline ::std::string* ConfigProto::mutable_device_filters(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.device_filters)
  return device_filters_.Mutable(index);
}
inline void ConfigProto::set_device_filters(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.device_filters)
  device_filters_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void ConfigProto::set_device_filters(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.device_filters)
  device_filters_.Mutable(index)->assign(std::move(value));
}
#endif
inline void ConfigProto::set_device_filters(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  device_filters_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.ConfigProto.device_filters)
}
inline void ConfigProto::set_device_filters(int index, const char* value, size_t size) {
  device_filters_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.ConfigProto.device_filters)
}
inline ::std::string* ConfigProto::add_device_filters() {
  // @@protoc_insertion_point(field_add_mutable:tensorflow.ConfigProto.device_filters)
  return device_filters_.Add();
}
inline void ConfigProto::add_device_filters(const ::std::string& value) {
  device_filters_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.ConfigProto.device_filters)
}
#if LANG_CXX11
inline void ConfigProto::add_device_filters(::std::string&& value) {
  device_filters_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.ConfigProto.device_filters)
}
#endif
inline void ConfigProto::add_device_filters(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  device_filters_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.ConfigProto.device_filters)
}
inline void ConfigProto::add_device_filters(const char* value, size_t size) {
  device_filters_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.ConfigProto.device_filters)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ConfigProto::device_filters() const {
  // @@protoc_insertion_point(field_list:tensorflow.ConfigProto.device_filters)
  return device_filters_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ConfigProto::mutable_device_filters() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.ConfigProto.device_filters)
  return &device_filters_;
}

// .tensorflow.GPUOptions gpu_options = 6;
inline bool ConfigProto::has_gpu_options() const {
  return this != internal_default_instance() && gpu_options_ != NULL;
}
inline void ConfigProto::clear_gpu_options() {
  if (GetArenaNoVirtual() == NULL && gpu_options_ != NULL) delete gpu_options_;
  gpu_options_ = NULL;
}
inline const ::tensorflow::GPUOptions& ConfigProto::gpu_options() const {
  const ::tensorflow::GPUOptions* p = gpu_options_;
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.gpu_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::GPUOptions*>(
      &::tensorflow::_GPUOptions_default_instance_);
}
inline ::tensorflow::GPUOptions* ConfigProto::mutable_gpu_options() {
  
  if (gpu_options_ == NULL) {
    _slow_mutable_gpu_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.gpu_options)
  return gpu_options_;
}
inline ::tensorflow::GPUOptions* ConfigProto::release_gpu_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.gpu_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_gpu_options();
  } else {
    ::tensorflow::GPUOptions* temp = gpu_options_;
    gpu_options_ = NULL;
    return temp;
  }
}
inline  void ConfigProto::set_allocated_gpu_options(::tensorflow::GPUOptions* gpu_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete gpu_options_;
  }
  if (gpu_options != NULL) {
    _slow_set_allocated_gpu_options(message_arena, &gpu_options);
  }
  gpu_options_ = gpu_options;
  if (gpu_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.gpu_options)
}

// bool allow_soft_placement = 7;
inline void ConfigProto::clear_allow_soft_placement() {
  allow_soft_placement_ = false;
}
inline bool ConfigProto::allow_soft_placement() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.allow_soft_placement)
  return allow_soft_placement_;
}
inline void ConfigProto::set_allow_soft_placement(bool value) {
  
  allow_soft_placement_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.allow_soft_placement)
}

// bool log_device_placement = 8;
inline void ConfigProto::clear_log_device_placement() {
  log_device_placement_ = false;
}
inline bool ConfigProto::log_device_placement() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.log_device_placement)
  return log_device_placement_;
}
inline void ConfigProto::set_log_device_placement(bool value) {
  
  log_device_placement_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.log_device_placement)
}

// .tensorflow.GraphOptions graph_options = 10;
inline bool ConfigProto::has_graph_options() const {
  return this != internal_default_instance() && graph_options_ != NULL;
}
inline void ConfigProto::clear_graph_options() {
  if (GetArenaNoVirtual() == NULL && graph_options_ != NULL) delete graph_options_;
  graph_options_ = NULL;
}
inline const ::tensorflow::GraphOptions& ConfigProto::graph_options() const {
  const ::tensorflow::GraphOptions* p = graph_options_;
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.graph_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::GraphOptions*>(
      &::tensorflow::_GraphOptions_default_instance_);
}
inline ::tensorflow::GraphOptions* ConfigProto::mutable_graph_options() {
  
  if (graph_options_ == NULL) {
    _slow_mutable_graph_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.graph_options)
  return graph_options_;
}
inline ::tensorflow::GraphOptions* ConfigProto::release_graph_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.graph_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_graph_options();
  } else {
    ::tensorflow::GraphOptions* temp = graph_options_;
    graph_options_ = NULL;
    return temp;
  }
}
inline  void ConfigProto::set_allocated_graph_options(::tensorflow::GraphOptions* graph_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete graph_options_;
  }
  if (graph_options != NULL) {
    _slow_set_allocated_graph_options(message_arena, &graph_options);
  }
  graph_options_ = graph_options;
  if (graph_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.graph_options)
}

// int64 operation_timeout_in_ms = 11;
inline void ConfigProto::clear_operation_timeout_in_ms() {
  operation_timeout_in_ms_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ConfigProto::operation_timeout_in_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.operation_timeout_in_ms)
  return operation_timeout_in_ms_;
}
inline void ConfigProto::set_operation_timeout_in_ms(::google::protobuf::int64 value) {
  
  operation_timeout_in_ms_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.operation_timeout_in_ms)
}

// .tensorflow.RPCOptions rpc_options = 13;
inline bool ConfigProto::has_rpc_options() const {
  return this != internal_default_instance() && rpc_options_ != NULL;
}
inline void ConfigProto::clear_rpc_options() {
  if (GetArenaNoVirtual() == NULL && rpc_options_ != NULL) delete rpc_options_;
  rpc_options_ = NULL;
}
inline const ::tensorflow::RPCOptions& ConfigProto::rpc_options() const {
  const ::tensorflow::RPCOptions* p = rpc_options_;
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.rpc_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::RPCOptions*>(
      &::tensorflow::_RPCOptions_default_instance_);
}
inline ::tensorflow::RPCOptions* ConfigProto::mutable_rpc_options() {
  
  if (rpc_options_ == NULL) {
    _slow_mutable_rpc_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.rpc_options)
  return rpc_options_;
}
inline ::tensorflow::RPCOptions* ConfigProto::release_rpc_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.rpc_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_rpc_options();
  } else {
    ::tensorflow::RPCOptions* temp = rpc_options_;
    rpc_options_ = NULL;
    return temp;
  }
}
inline  void ConfigProto::set_allocated_rpc_options(::tensorflow::RPCOptions* rpc_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete rpc_options_;
  }
  if (rpc_options != NULL) {
    _slow_set_allocated_rpc_options(message_arena, &rpc_options);
  }
  rpc_options_ = rpc_options;
  if (rpc_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.rpc_options)
}

// .tensorflow.ClusterDef cluster_def = 14;
inline bool ConfigProto::has_cluster_def() const {
  return this != internal_default_instance() && cluster_def_ != NULL;
}
inline void ConfigProto::clear_cluster_def() {
  if (GetArenaNoVirtual() == NULL && cluster_def_ != NULL) delete cluster_def_;
  cluster_def_ = NULL;
}
inline const ::tensorflow::ClusterDef& ConfigProto::cluster_def() const {
  const ::tensorflow::ClusterDef* p = cluster_def_;
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.cluster_def)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::ClusterDef*>(
      &::tensorflow::_ClusterDef_default_instance_);
}
inline ::tensorflow::ClusterDef* ConfigProto::mutable_cluster_def() {
  
  if (cluster_def_ == NULL) {
    _slow_mutable_cluster_def();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.cluster_def)
  return cluster_def_;
}
inline ::tensorflow::ClusterDef* ConfigProto::release_cluster_def() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.cluster_def)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_cluster_def();
  } else {
    ::tensorflow::ClusterDef* temp = cluster_def_;
    cluster_def_ = NULL;
    return temp;
  }
}
inline  void ConfigProto::set_allocated_cluster_def(::tensorflow::ClusterDef* cluster_def) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete cluster_def_;
  }
  if (cluster_def != NULL) {
    _slow_set_allocated_cluster_def(message_arena, &cluster_def);
  }
  cluster_def_ = cluster_def;
  if (cluster_def) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.cluster_def)
}

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

// RunOptions

// .tensorflow.RunOptions.TraceLevel trace_level = 1;
inline void RunOptions::clear_trace_level() {
  trace_level_ = 0;
}
inline ::tensorflow::RunOptions_TraceLevel RunOptions::trace_level() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.trace_level)
  return static_cast< ::tensorflow::RunOptions_TraceLevel >(trace_level_);
}
inline void RunOptions::set_trace_level(::tensorflow::RunOptions_TraceLevel value) {
  
  trace_level_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.trace_level)
}

// int64 timeout_in_ms = 2;
inline void RunOptions::clear_timeout_in_ms() {
  timeout_in_ms_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RunOptions::timeout_in_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.timeout_in_ms)
  return timeout_in_ms_;
}
inline void RunOptions::set_timeout_in_ms(::google::protobuf::int64 value) {
  
  timeout_in_ms_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.timeout_in_ms)
}

// int32 inter_op_thread_pool = 3;
inline void RunOptions::clear_inter_op_thread_pool() {
  inter_op_thread_pool_ = 0;
}
inline ::google::protobuf::int32 RunOptions::inter_op_thread_pool() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.inter_op_thread_pool)
  return inter_op_thread_pool_;
}
inline void RunOptions::set_inter_op_thread_pool(::google::protobuf::int32 value) {
  
  inter_op_thread_pool_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.inter_op_thread_pool)
}

// bool output_partition_graphs = 5;
inline void RunOptions::clear_output_partition_graphs() {
  output_partition_graphs_ = false;
}
inline bool RunOptions::output_partition_graphs() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.output_partition_graphs)
  return output_partition_graphs_;
}
inline void RunOptions::set_output_partition_graphs(bool value) {
  
  output_partition_graphs_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.output_partition_graphs)
}

// .tensorflow.DebugOptions debug_options = 6;
inline bool RunOptions::has_debug_options() const {
  return this != internal_default_instance() && debug_options_ != NULL;
}
inline void RunOptions::clear_debug_options() {
  if (GetArenaNoVirtual() == NULL && debug_options_ != NULL) delete debug_options_;
  debug_options_ = NULL;
}
inline const ::tensorflow::DebugOptions& RunOptions::debug_options() const {
  const ::tensorflow::DebugOptions* p = debug_options_;
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.debug_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::DebugOptions*>(
      &::tensorflow::_DebugOptions_default_instance_);
}
inline ::tensorflow::DebugOptions* RunOptions::mutable_debug_options() {
  
  if (debug_options_ == NULL) {
    _slow_mutable_debug_options();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunOptions.debug_options)
  return debug_options_;
}
inline ::tensorflow::DebugOptions* RunOptions::release_debug_options() {
  // @@protoc_insertion_point(field_release:tensorflow.RunOptions.debug_options)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_debug_options();
  } else {
    ::tensorflow::DebugOptions* temp = debug_options_;
    debug_options_ = NULL;
    return temp;
  }
}
inline  void RunOptions::set_allocated_debug_options(::tensorflow::DebugOptions* debug_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete debug_options_;
  }
  if (debug_options != NULL) {
    _slow_set_allocated_debug_options(message_arena, &debug_options);
  }
  debug_options_ = debug_options;
  if (debug_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.RunOptions.debug_options)
}

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

// RunMetadata

// .tensorflow.StepStats step_stats = 1;
inline bool RunMetadata::has_step_stats() const {
  return this != internal_default_instance() && step_stats_ != NULL;
}
inline void RunMetadata::clear_step_stats() {
  if (GetArenaNoVirtual() == NULL && step_stats_ != NULL) delete step_stats_;
  step_stats_ = NULL;
}
inline const ::tensorflow::StepStats& RunMetadata::step_stats() const {
  const ::tensorflow::StepStats* p = step_stats_;
  // @@protoc_insertion_point(field_get:tensorflow.RunMetadata.step_stats)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::StepStats*>(
      &::tensorflow::_StepStats_default_instance_);
}
inline ::tensorflow::StepStats* RunMetadata::mutable_step_stats() {
  
  if (step_stats_ == NULL) {
    _slow_mutable_step_stats();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.step_stats)
  return step_stats_;
}
inline ::tensorflow::StepStats* RunMetadata::release_step_stats() {
  // @@protoc_insertion_point(field_release:tensorflow.RunMetadata.step_stats)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_step_stats();
  } else {
    ::tensorflow::StepStats* temp = step_stats_;
    step_stats_ = NULL;
    return temp;
  }
}
inline  void RunMetadata::set_allocated_step_stats(::tensorflow::StepStats* step_stats) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete step_stats_;
  }
  if (step_stats != NULL) {
    _slow_set_allocated_step_stats(message_arena, &step_stats);
  }
  step_stats_ = step_stats;
  if (step_stats) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.RunMetadata.step_stats)
}

// .tensorflow.CostGraphDef cost_graph = 2;
inline bool RunMetadata::has_cost_graph() const {
  return this != internal_default_instance() && cost_graph_ != NULL;
}
inline void RunMetadata::clear_cost_graph() {
  if (GetArenaNoVirtual() == NULL && cost_graph_ != NULL) delete cost_graph_;
  cost_graph_ = NULL;
}
inline const ::tensorflow::CostGraphDef& RunMetadata::cost_graph() const {
  const ::tensorflow::CostGraphDef* p = cost_graph_;
  // @@protoc_insertion_point(field_get:tensorflow.RunMetadata.cost_graph)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::CostGraphDef*>(
      &::tensorflow::_CostGraphDef_default_instance_);
}
inline ::tensorflow::CostGraphDef* RunMetadata::mutable_cost_graph() {
  
  if (cost_graph_ == NULL) {
    _slow_mutable_cost_graph();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.cost_graph)
  return cost_graph_;
}
inline ::tensorflow::CostGraphDef* RunMetadata::release_cost_graph() {
  // @@protoc_insertion_point(field_release:tensorflow.RunMetadata.cost_graph)
  
  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_cost_graph();
  } else {
    ::tensorflow::CostGraphDef* temp = cost_graph_;
    cost_graph_ = NULL;
    return temp;
  }
}
inline  void RunMetadata::set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete cost_graph_;
  }
  if (cost_graph != NULL) {
    _slow_set_allocated_cost_graph(message_arena, &cost_graph);
  }
  cost_graph_ = cost_graph;
  if (cost_graph) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.RunMetadata.cost_graph)
}

// repeated .tensorflow.GraphDef partition_graphs = 3;
inline int RunMetadata::partition_graphs_size() const {
  return partition_graphs_.size();
}
inline void RunMetadata::clear_partition_graphs() {
  partition_graphs_.Clear();
}
inline const ::tensorflow::GraphDef& RunMetadata::partition_graphs(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_.Get(index);
}
inline ::tensorflow::GraphDef* RunMetadata::mutable_partition_graphs(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_.Mutable(index);
}
inline ::tensorflow::GraphDef* RunMetadata::add_partition_graphs() {
  // @@protoc_insertion_point(field_add:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >*
RunMetadata::mutable_partition_graphs() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.RunMetadata.partition_graphs)
  return &partition_graphs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >&
RunMetadata::partition_graphs() const {
  // @@protoc_insertion_point(field_list:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


}  // namespace tensorflow

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::tensorflow::OptimizerOptions_Level> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::OptimizerOptions_Level>() {
  return ::tensorflow::OptimizerOptions_Level_descriptor();
}
template <> struct is_proto_enum< ::tensorflow::OptimizerOptions_GlobalJitLevel> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::OptimizerOptions_GlobalJitLevel>() {
  return ::tensorflow::OptimizerOptions_GlobalJitLevel_descriptor();
}
template <> struct is_proto_enum< ::tensorflow::RunOptions_TraceLevel> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::RunOptions_TraceLevel>() {
  return ::tensorflow::RunOptions_TraceLevel_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED
