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

#ifndef PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto
#define PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < 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/inlined_string_field.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)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto 

namespace protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[17];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto
namespace tensorflow {
class CallableOptions;
class CallableOptionsDefaultTypeInternal;
extern CallableOptionsDefaultTypeInternal _CallableOptions_default_instance_;
class CallableOptions_FeedDevicesEntry_DoNotUse;
class CallableOptions_FeedDevicesEntry_DoNotUseDefaultTypeInternal;
extern CallableOptions_FeedDevicesEntry_DoNotUseDefaultTypeInternal _CallableOptions_FeedDevicesEntry_DoNotUse_default_instance_;
class CallableOptions_FetchDevicesEntry_DoNotUse;
class CallableOptions_FetchDevicesEntry_DoNotUseDefaultTypeInternal;
extern CallableOptions_FetchDevicesEntry_DoNotUseDefaultTypeInternal _CallableOptions_FetchDevicesEntry_DoNotUse_default_instance_;
class ConfigProto;
class ConfigProtoDefaultTypeInternal;
extern ConfigProtoDefaultTypeInternal _ConfigProto_default_instance_;
class ConfigProto_DeviceCountEntry_DoNotUse;
class ConfigProto_DeviceCountEntry_DoNotUseDefaultTypeInternal;
extern ConfigProto_DeviceCountEntry_DoNotUseDefaultTypeInternal _ConfigProto_DeviceCountEntry_DoNotUse_default_instance_;
class ConfigProto_Experimental;
class ConfigProto_ExperimentalDefaultTypeInternal;
extern ConfigProto_ExperimentalDefaultTypeInternal _ConfigProto_Experimental_default_instance_;
class GPUOptions;
class GPUOptionsDefaultTypeInternal;
extern GPUOptionsDefaultTypeInternal _GPUOptions_default_instance_;
class GPUOptions_Experimental;
class GPUOptions_ExperimentalDefaultTypeInternal;
extern GPUOptions_ExperimentalDefaultTypeInternal _GPUOptions_Experimental_default_instance_;
class GPUOptions_Experimental_VirtualDevices;
class GPUOptions_Experimental_VirtualDevicesDefaultTypeInternal;
extern GPUOptions_Experimental_VirtualDevicesDefaultTypeInternal _GPUOptions_Experimental_VirtualDevices_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 RunOptions_Experimental;
class RunOptions_ExperimentalDefaultTypeInternal;
extern RunOptions_ExperimentalDefaultTypeInternal _RunOptions_Experimental_default_instance_;
class TensorConnection;
class TensorConnectionDefaultTypeInternal;
extern TensorConnectionDefaultTypeInternal _TensorConnection_default_instance_;
class ThreadPoolOptionProto;
class ThreadPoolOptionProtoDefaultTypeInternal;
extern ThreadPoolOptionProtoDefaultTypeInternal _ThreadPoolOptionProto_default_instance_;
}  // namespace tensorflow
namespace google {
namespace protobuf {
template<> ::tensorflow::CallableOptions* Arena::CreateMaybeMessage<::tensorflow::CallableOptions>(Arena*);
template<> ::tensorflow::CallableOptions_FeedDevicesEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::CallableOptions_FeedDevicesEntry_DoNotUse>(Arena*);
template<> ::tensorflow::CallableOptions_FetchDevicesEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::CallableOptions_FetchDevicesEntry_DoNotUse>(Arena*);
template<> ::tensorflow::ConfigProto* Arena::CreateMaybeMessage<::tensorflow::ConfigProto>(Arena*);
template<> ::tensorflow::ConfigProto_DeviceCountEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::ConfigProto_DeviceCountEntry_DoNotUse>(Arena*);
template<> ::tensorflow::ConfigProto_Experimental* Arena::CreateMaybeMessage<::tensorflow::ConfigProto_Experimental>(Arena*);
template<> ::tensorflow::GPUOptions* Arena::CreateMaybeMessage<::tensorflow::GPUOptions>(Arena*);
template<> ::tensorflow::GPUOptions_Experimental* Arena::CreateMaybeMessage<::tensorflow::GPUOptions_Experimental>(Arena*);
template<> ::tensorflow::GPUOptions_Experimental_VirtualDevices* Arena::CreateMaybeMessage<::tensorflow::GPUOptions_Experimental_VirtualDevices>(Arena*);
template<> ::tensorflow::GraphOptions* Arena::CreateMaybeMessage<::tensorflow::GraphOptions>(Arena*);
template<> ::tensorflow::OptimizerOptions* Arena::CreateMaybeMessage<::tensorflow::OptimizerOptions>(Arena*);
template<> ::tensorflow::RPCOptions* Arena::CreateMaybeMessage<::tensorflow::RPCOptions>(Arena*);
template<> ::tensorflow::RunMetadata* Arena::CreateMaybeMessage<::tensorflow::RunMetadata>(Arena*);
template<> ::tensorflow::RunOptions* Arena::CreateMaybeMessage<::tensorflow::RunOptions>(Arena*);
template<> ::tensorflow::RunOptions_Experimental* Arena::CreateMaybeMessage<::tensorflow::RunOptions_Experimental>(Arena*);
template<> ::tensorflow::TensorConnection* Arena::CreateMaybeMessage<::tensorflow::TensorConnection>(Arena*);
template<> ::tensorflow::ThreadPoolOptionProto* Arena::CreateMaybeMessage<::tensorflow::ThreadPoolOptionProto>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace tensorflow {

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_Experimental_VirtualDevices : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.GPUOptions.Experimental.VirtualDevices) */ {
 public:
  GPUOptions_Experimental_VirtualDevices();
  virtual ~GPUOptions_Experimental_VirtualDevices();

  GPUOptions_Experimental_VirtualDevices(const GPUOptions_Experimental_VirtualDevices& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GPUOptions_Experimental_VirtualDevices* internal_default_instance() {
    return reinterpret_cast<const GPUOptions_Experimental_VirtualDevices*>(
               &_GPUOptions_Experimental_VirtualDevices_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  inline GPUOptions_Experimental_VirtualDevices* New() const final {
    return CreateMaybeMessage<GPUOptions_Experimental_VirtualDevices>(NULL);
  }

  GPUOptions_Experimental_VirtualDevices* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GPUOptions_Experimental_VirtualDevices>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GPUOptions_Experimental_VirtualDevices& from);
  void MergeFrom(const GPUOptions_Experimental_VirtualDevices& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GPUOptions_Experimental_VirtualDevices* other);
  protected:
  explicit GPUOptions_Experimental_VirtualDevices(::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 final;

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

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

  // repeated float memory_limit_mb = 1;
  int memory_limit_mb_size() const;
  void clear_memory_limit_mb();
  static const int kMemoryLimitMbFieldNumber = 1;
  float memory_limit_mb(int index) const;
  void set_memory_limit_mb(int index, float value);
  void add_memory_limit_mb(float value);
  const ::google::protobuf::RepeatedField< float >&
      memory_limit_mb() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_memory_limit_mb();

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

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

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

  GPUOptions_Experimental(const GPUOptions_Experimental& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GPUOptions_Experimental* internal_default_instance() {
    return reinterpret_cast<const GPUOptions_Experimental*>(
               &_GPUOptions_Experimental_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

  inline GPUOptions_Experimental* New() const final {
    return CreateMaybeMessage<GPUOptions_Experimental>(NULL);
  }

  GPUOptions_Experimental* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GPUOptions_Experimental>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GPUOptions_Experimental& from);
  void MergeFrom(const GPUOptions_Experimental& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GPUOptions_Experimental* other);
  protected:
  explicit GPUOptions_Experimental(::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 final;

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

  typedef GPUOptions_Experimental_VirtualDevices VirtualDevices;

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

  // repeated .tensorflow.GPUOptions.Experimental.VirtualDevices virtual_devices = 1;
  int virtual_devices_size() const;
  void clear_virtual_devices();
  static const int kVirtualDevicesFieldNumber = 1;
  ::tensorflow::GPUOptions_Experimental_VirtualDevices* mutable_virtual_devices(int index);
  ::google::protobuf::RepeatedPtrField< ::tensorflow::GPUOptions_Experimental_VirtualDevices >*
      mutable_virtual_devices();
  const ::tensorflow::GPUOptions_Experimental_VirtualDevices& virtual_devices(int index) const;
  ::tensorflow::GPUOptions_Experimental_VirtualDevices* add_virtual_devices();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::GPUOptions_Experimental_VirtualDevices >&
      virtual_devices() const;

  // bool use_unified_memory = 2;
  void clear_use_unified_memory();
  static const int kUseUnifiedMemoryFieldNumber = 2;
  bool use_unified_memory() const;
  void set_use_unified_memory(bool value);

  // int32 num_dev_to_dev_copy_streams = 3;
  void clear_num_dev_to_dev_copy_streams();
  static const int kNumDevToDevCopyStreamsFieldNumber = 3;
  ::google::protobuf::int32 num_dev_to_dev_copy_streams() const;
  void set_num_dev_to_dev_copy_streams(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:tensorflow.GPUOptions.Experimental)
 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::GPUOptions_Experimental_VirtualDevices > virtual_devices_;
  bool use_unified_memory_;
  ::google::protobuf::int32 num_dev_to_dev_copy_streams_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GPUOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GPUOptions* internal_default_instance() {
    return reinterpret_cast<const GPUOptions*>(
               &_GPUOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  inline GPUOptions* New() const final {
    return CreateMaybeMessage<GPUOptions>(NULL);
  }

  GPUOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GPUOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GPUOptions& from);
  void MergeFrom(const GPUOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 final;

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

  typedef GPUOptions_Experimental Experimental;

  // 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);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_allocator_type();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  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);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_visible_device_list();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_visible_device_list(
      ::std::string* visible_device_list);

  // .tensorflow.GPUOptions.Experimental experimental = 9;
  bool has_experimental() const;
  void clear_experimental();
  static const int kExperimentalFieldNumber = 9;
  private:
  const ::tensorflow::GPUOptions_Experimental& _internal_experimental() const;
  public:
  const ::tensorflow::GPUOptions_Experimental& experimental() const;
  ::tensorflow::GPUOptions_Experimental* release_experimental();
  ::tensorflow::GPUOptions_Experimental* mutable_experimental();
  void set_allocated_experimental(::tensorflow::GPUOptions_Experimental* experimental);
  void unsafe_arena_set_allocated_experimental(
      ::tensorflow::GPUOptions_Experimental* experimental);
  ::tensorflow::GPUOptions_Experimental* unsafe_arena_release_experimental();

  // 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_;
  ::tensorflow::GPUOptions_Experimental* experimental_;
  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 ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OptimizerOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OptimizerOptions* internal_default_instance() {
    return reinterpret_cast<const OptimizerOptions*>(
               &_OptimizerOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  inline OptimizerOptions* New() const final {
    return CreateMaybeMessage<OptimizerOptions>(NULL);
  }

  OptimizerOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OptimizerOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const OptimizerOptions& from);
  void MergeFrom(const OptimizerOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 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);

  // int64 max_folded_constant_in_bytes = 6;
  void clear_max_folded_constant_in_bytes();
  static const int kMaxFoldedConstantInBytesFieldNumber = 6;
  ::google::protobuf::int64 max_folded_constant_in_bytes() const;
  void set_max_folded_constant_in_bytes(::google::protobuf::int64 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_;
  ::google::protobuf::int64 max_folded_constant_in_bytes_;
  int global_jit_level_;
  mutable ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GraphOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GraphOptions* internal_default_instance() {
    return reinterpret_cast<const GraphOptions*>(
               &_GraphOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  inline GraphOptions* New() const final {
    return CreateMaybeMessage<GraphOptions>(NULL);
  }

  GraphOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GraphOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GraphOptions& from);
  void MergeFrom(const GraphOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 final;

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

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

  // .tensorflow.OptimizerOptions optimizer_options = 3;
  bool has_optimizer_options() const;
  void clear_optimizer_options();
  static const int kOptimizerOptionsFieldNumber = 3;
  private:
  const ::tensorflow::OptimizerOptions& _internal_optimizer_options() const;
  public:
  const ::tensorflow::OptimizerOptions& optimizer_options() const;
  ::tensorflow::OptimizerOptions* release_optimizer_options();
  ::tensorflow::OptimizerOptions* mutable_optimizer_options();
  void set_allocated_optimizer_options(::tensorflow::OptimizerOptions* optimizer_options);
  void unsafe_arena_set_allocated_optimizer_options(
      ::tensorflow::OptimizerOptions* optimizer_options);
  ::tensorflow::OptimizerOptions* unsafe_arena_release_optimizer_options();

  // .tensorflow.RewriterConfig rewrite_options = 10;
  bool has_rewrite_options() const;
  void clear_rewrite_options();
  static const int kRewriteOptionsFieldNumber = 10;
  private:
  const ::tensorflow::RewriterConfig& _internal_rewrite_options() const;
  public:
  const ::tensorflow::RewriterConfig& rewrite_options() const;
  ::tensorflow::RewriterConfig* release_rewrite_options();
  ::tensorflow::RewriterConfig* mutable_rewrite_options();
  void set_allocated_rewrite_options(::tensorflow::RewriterConfig* rewrite_options);
  void unsafe_arena_set_allocated_rewrite_options(
      ::tensorflow::RewriterConfig* rewrite_options);
  ::tensorflow::RewriterConfig* unsafe_arena_release_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 ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ThreadPoolOptionProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ThreadPoolOptionProto* internal_default_instance() {
    return reinterpret_cast<const ThreadPoolOptionProto*>(
               &_ThreadPoolOptionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

  inline ThreadPoolOptionProto* New() const final {
    return CreateMaybeMessage<ThreadPoolOptionProto>(NULL);
  }

  ThreadPoolOptionProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ThreadPoolOptionProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ThreadPoolOptionProto& from);
  void MergeFrom(const ThreadPoolOptionProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 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);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_global_name();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  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 ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RPCOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RPCOptions* internal_default_instance() {
    return reinterpret_cast<const RPCOptions*>(
               &_RPCOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

  inline RPCOptions* New() const final {
    return CreateMaybeMessage<RPCOptions>(NULL);
  }

  RPCOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RPCOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RPCOptions& from);
  void MergeFrom(const RPCOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 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 ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ConfigProto_DeviceCountEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<ConfigProto_DeviceCountEntry_DoNotUse, 
    ::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_DoNotUse, 
    ::std::string, ::google::protobuf::int32,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
    0 > SuperType;
  ConfigProto_DeviceCountEntry_DoNotUse();
  ConfigProto_DeviceCountEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const ConfigProto_DeviceCountEntry_DoNotUse& other);
  static const ConfigProto_DeviceCountEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ConfigProto_DeviceCountEntry_DoNotUse*>(&_ConfigProto_DeviceCountEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

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

  ConfigProto_Experimental(const ConfigProto_Experimental& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConfigProto_Experimental* internal_default_instance() {
    return reinterpret_cast<const ConfigProto_Experimental*>(
               &_ConfigProto_Experimental_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

  inline ConfigProto_Experimental* New() const final {
    return CreateMaybeMessage<ConfigProto_Experimental>(NULL);
  }

  ConfigProto_Experimental* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ConfigProto_Experimental>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ConfigProto_Experimental& from);
  void MergeFrom(const ConfigProto_Experimental& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConfigProto_Experimental* other);
  protected:
  explicit ConfigProto_Experimental(::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 final;

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

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

  // string collective_group_leader = 1;
  void clear_collective_group_leader();
  static const int kCollectiveGroupLeaderFieldNumber = 1;
  const ::std::string& collective_group_leader() const;
  void set_collective_group_leader(const ::std::string& value);
  #if LANG_CXX11
  void set_collective_group_leader(::std::string&& value);
  #endif
  void set_collective_group_leader(const char* value);
  void set_collective_group_leader(const char* value, size_t size);
  ::std::string* mutable_collective_group_leader();
  ::std::string* release_collective_group_leader();
  void set_allocated_collective_group_leader(::std::string* collective_group_leader);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_collective_group_leader();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_collective_group_leader(
      ::std::string* collective_group_leader);

  // string executor_type = 3;
  void clear_executor_type();
  static const int kExecutorTypeFieldNumber = 3;
  const ::std::string& executor_type() const;
  void set_executor_type(const ::std::string& value);
  #if LANG_CXX11
  void set_executor_type(::std::string&& value);
  #endif
  void set_executor_type(const char* value);
  void set_executor_type(const char* value, size_t size);
  ::std::string* mutable_executor_type();
  ::std::string* release_executor_type();
  void set_allocated_executor_type(::std::string* executor_type);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_executor_type();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_executor_type(
      ::std::string* executor_type);

  // @@protoc_insertion_point(class_scope:tensorflow.ConfigProto.Experimental)
 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 collective_group_leader_;
  ::google::protobuf::internal::ArenaStringPtr executor_type_;
  mutable ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ConfigProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConfigProto* internal_default_instance() {
    return reinterpret_cast<const ConfigProto*>(
               &_ConfigProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

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

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

  inline ConfigProto* New() const final {
    return CreateMaybeMessage<ConfigProto>(NULL);
  }

  ConfigProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ConfigProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ConfigProto& from);
  void MergeFrom(const ConfigProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 final;

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

  typedef ConfigProto_Experimental Experimental;

  // 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;
  ::tensorflow::ThreadPoolOptionProto* mutable_session_inter_op_thread_pool(int index);
  ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto >*
      mutable_session_inter_op_thread_pool();
  const ::tensorflow::ThreadPoolOptionProto& session_inter_op_thread_pool(int index) const;
  ::tensorflow::ThreadPoolOptionProto* add_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:
  const ::tensorflow::GPUOptions& _internal_gpu_options() const;
  public:
  const ::tensorflow::GPUOptions& gpu_options() const;
  ::tensorflow::GPUOptions* release_gpu_options();
  ::tensorflow::GPUOptions* mutable_gpu_options();
  void set_allocated_gpu_options(::tensorflow::GPUOptions* gpu_options);
  void unsafe_arena_set_allocated_gpu_options(
      ::tensorflow::GPUOptions* gpu_options);
  ::tensorflow::GPUOptions* unsafe_arena_release_gpu_options();

  // .tensorflow.GraphOptions graph_options = 10;
  bool has_graph_options() const;
  void clear_graph_options();
  static const int kGraphOptionsFieldNumber = 10;
  private:
  const ::tensorflow::GraphOptions& _internal_graph_options() const;
  public:
  const ::tensorflow::GraphOptions& graph_options() const;
  ::tensorflow::GraphOptions* release_graph_options();
  ::tensorflow::GraphOptions* mutable_graph_options();
  void set_allocated_graph_options(::tensorflow::GraphOptions* graph_options);
  void unsafe_arena_set_allocated_graph_options(
      ::tensorflow::GraphOptions* graph_options);
  ::tensorflow::GraphOptions* unsafe_arena_release_graph_options();

  // .tensorflow.RPCOptions rpc_options = 13;
  bool has_rpc_options() const;
  void clear_rpc_options();
  static const int kRpcOptionsFieldNumber = 13;
  private:
  const ::tensorflow::RPCOptions& _internal_rpc_options() const;
  public:
  const ::tensorflow::RPCOptions& rpc_options() const;
  ::tensorflow::RPCOptions* release_rpc_options();
  ::tensorflow::RPCOptions* mutable_rpc_options();
  void set_allocated_rpc_options(::tensorflow::RPCOptions* rpc_options);
  void unsafe_arena_set_allocated_rpc_options(
      ::tensorflow::RPCOptions* rpc_options);
  ::tensorflow::RPCOptions* unsafe_arena_release_rpc_options();

  // .tensorflow.ClusterDef cluster_def = 14;
  bool has_cluster_def() const;
  void clear_cluster_def();
  static const int kClusterDefFieldNumber = 14;
  private:
  const ::tensorflow::ClusterDef& _internal_cluster_def() const;
  public:
  const ::tensorflow::ClusterDef& cluster_def() const;
  ::tensorflow::ClusterDef* release_cluster_def();
  ::tensorflow::ClusterDef* mutable_cluster_def();
  void set_allocated_cluster_def(::tensorflow::ClusterDef* cluster_def);
  void unsafe_arena_set_allocated_cluster_def(
      ::tensorflow::ClusterDef* cluster_def);
  ::tensorflow::ClusterDef* unsafe_arena_release_cluster_def();

  // .tensorflow.ConfigProto.Experimental experimental = 16;
  bool has_experimental() const;
  void clear_experimental();
  static const int kExperimentalFieldNumber = 16;
  private:
  const ::tensorflow::ConfigProto_Experimental& _internal_experimental() const;
  public:
  const ::tensorflow::ConfigProto_Experimental& experimental() const;
  ::tensorflow::ConfigProto_Experimental* release_experimental();
  ::tensorflow::ConfigProto_Experimental* mutable_experimental();
  void set_allocated_experimental(::tensorflow::ConfigProto_Experimental* experimental);
  void unsafe_arena_set_allocated_experimental(
      ::tensorflow::ConfigProto_Experimental* experimental);
  ::tensorflow::ConfigProto_Experimental* unsafe_arena_release_experimental();

  // 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);

  // bool isolate_session_state = 15;
  void clear_isolate_session_state();
  static const int kIsolateSessionStateFieldNumber = 15;
  bool isolate_session_state() const;
  void set_isolate_session_state(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_;
  ::google::protobuf::internal::MapField<
      ConfigProto_DeviceCountEntry_DoNotUse,
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 > device_count_;
  ::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_;
  ::tensorflow::ConfigProto_Experimental* experimental_;
  ::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_;
  bool isolate_session_state_;
  ::google::protobuf::int64 operation_timeout_in_ms_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  RunOptions_Experimental(const RunOptions_Experimental& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RunOptions_Experimental* internal_default_instance() {
    return reinterpret_cast<const RunOptions_Experimental*>(
               &_RunOptions_Experimental_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

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

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

  inline RunOptions_Experimental* New() const final {
    return CreateMaybeMessage<RunOptions_Experimental>(NULL);
  }

  RunOptions_Experimental* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RunOptions_Experimental>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RunOptions_Experimental& from);
  void MergeFrom(const RunOptions_Experimental& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RunOptions_Experimental* other);
  protected:
  explicit RunOptions_Experimental(::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 final;

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

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

  // int64 collective_graph_key = 1;
  void clear_collective_graph_key();
  static const int kCollectiveGraphKeyFieldNumber = 1;
  ::google::protobuf::int64 collective_graph_key() const;
  void set_collective_graph_key(::google::protobuf::int64 value);

  // bool use_run_handler_pool = 2;
  void clear_use_run_handler_pool();
  static const int kUseRunHandlerPoolFieldNumber = 2;
  bool use_run_handler_pool() const;
  void set_use_run_handler_pool(bool value);

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::int64 collective_graph_key_;
  bool use_run_handler_pool_;
  mutable ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RunOptions* internal_default_instance() {
    return reinterpret_cast<const RunOptions*>(
               &_RunOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

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

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

  inline RunOptions* New() const final {
    return CreateMaybeMessage<RunOptions>(NULL);
  }

  RunOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RunOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RunOptions& from);
  void MergeFrom(const RunOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 final;

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

  typedef RunOptions_Experimental Experimental;

  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:
  const ::tensorflow::DebugOptions& _internal_debug_options() const;
  public:
  const ::tensorflow::DebugOptions& debug_options() const;
  ::tensorflow::DebugOptions* release_debug_options();
  ::tensorflow::DebugOptions* mutable_debug_options();
  void set_allocated_debug_options(::tensorflow::DebugOptions* debug_options);
  void unsafe_arena_set_allocated_debug_options(
      ::tensorflow::DebugOptions* debug_options);
  ::tensorflow::DebugOptions* unsafe_arena_release_debug_options();

  // .tensorflow.RunOptions.Experimental experimental = 8;
  bool has_experimental() const;
  void clear_experimental();
  static const int kExperimentalFieldNumber = 8;
  private:
  const ::tensorflow::RunOptions_Experimental& _internal_experimental() const;
  public:
  const ::tensorflow::RunOptions_Experimental& experimental() const;
  ::tensorflow::RunOptions_Experimental* release_experimental();
  ::tensorflow::RunOptions_Experimental* mutable_experimental();
  void set_allocated_experimental(::tensorflow::RunOptions_Experimental* experimental);
  void unsafe_arena_set_allocated_experimental(
      ::tensorflow::RunOptions_Experimental* experimental);
  ::tensorflow::RunOptions_Experimental* unsafe_arena_release_experimental();

  // 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);

  // bool report_tensor_allocations_upon_oom = 7;
  void clear_report_tensor_allocations_upon_oom();
  static const int kReportTensorAllocationsUponOomFieldNumber = 7;
  bool report_tensor_allocations_upon_oom() const;
  void set_report_tensor_allocations_upon_oom(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_;
  ::tensorflow::RunOptions_Experimental* experimental_;
  ::google::protobuf::int64 timeout_in_ms_;
  int trace_level_;
  ::google::protobuf::int32 inter_op_thread_pool_;
  bool output_partition_graphs_;
  bool report_tensor_allocations_upon_oom_;
  mutable ::google::protobuf::internal::CachedSize _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 final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunMetadata& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RunMetadata* internal_default_instance() {
    return reinterpret_cast<const RunMetadata*>(
               &_RunMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

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

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

  inline RunMetadata* New() const final {
    return CreateMaybeMessage<RunMetadata>(NULL);
  }

  RunMetadata* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RunMetadata>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RunMetadata& from);
  void MergeFrom(const RunMetadata& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const 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 final;

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

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

  // repeated .tensorflow.GraphDef partition_graphs = 3;
  int partition_graphs_size() const;
  void clear_partition_graphs();
  static const int kPartitionGraphsFieldNumber = 3;
  ::tensorflow::GraphDef* mutable_partition_graphs(int index);
  ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >*
      mutable_partition_graphs();
  const ::tensorflow::GraphDef& partition_graphs(int index) const;
  ::tensorflow::GraphDef* add_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:
  const ::tensorflow::StepStats& _internal_step_stats() const;
  public:
  const ::tensorflow::StepStats& step_stats() const;
  ::tensorflow::StepStats* release_step_stats();
  ::tensorflow::StepStats* mutable_step_stats();
  void set_allocated_step_stats(::tensorflow::StepStats* step_stats);
  void unsafe_arena_set_allocated_step_stats(
      ::tensorflow::StepStats* step_stats);
  ::tensorflow::StepStats* unsafe_arena_release_step_stats();

  // .tensorflow.CostGraphDef cost_graph = 2;
  bool has_cost_graph() const;
  void clear_cost_graph();
  static const int kCostGraphFieldNumber = 2;
  private:
  const ::tensorflow::CostGraphDef& _internal_cost_graph() const;
  public:
  const ::tensorflow::CostGraphDef& cost_graph() const;
  ::tensorflow::CostGraphDef* release_cost_graph();
  ::tensorflow::CostGraphDef* mutable_cost_graph();
  void set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph);
  void unsafe_arena_set_allocated_cost_graph(
      ::tensorflow::CostGraphDef* cost_graph);
  ::tensorflow::CostGraphDef* unsafe_arena_release_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 ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TensorConnection(const TensorConnection& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorConnection* internal_default_instance() {
    return reinterpret_cast<const TensorConnection*>(
               &_TensorConnection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

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

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

  inline TensorConnection* New() const final {
    return CreateMaybeMessage<TensorConnection>(NULL);
  }

  TensorConnection* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorConnection>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorConnection& from);
  void MergeFrom(const TensorConnection& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorConnection* other);
  protected:
  explicit TensorConnection(::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 final;

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

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

  // string from_tensor = 1;
  void clear_from_tensor();
  static const int kFromTensorFieldNumber = 1;
  const ::std::string& from_tensor() const;
  void set_from_tensor(const ::std::string& value);
  #if LANG_CXX11
  void set_from_tensor(::std::string&& value);
  #endif
  void set_from_tensor(const char* value);
  void set_from_tensor(const char* value, size_t size);
  ::std::string* mutable_from_tensor();
  ::std::string* release_from_tensor();
  void set_allocated_from_tensor(::std::string* from_tensor);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_from_tensor();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_from_tensor(
      ::std::string* from_tensor);

  // string to_tensor = 2;
  void clear_to_tensor();
  static const int kToTensorFieldNumber = 2;
  const ::std::string& to_tensor() const;
  void set_to_tensor(const ::std::string& value);
  #if LANG_CXX11
  void set_to_tensor(::std::string&& value);
  #endif
  void set_to_tensor(const char* value);
  void set_to_tensor(const char* value, size_t size);
  ::std::string* mutable_to_tensor();
  ::std::string* release_to_tensor();
  void set_allocated_to_tensor(::std::string* to_tensor);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_to_tensor();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_to_tensor(
      ::std::string* to_tensor);

  // @@protoc_insertion_point(class_scope:tensorflow.TensorConnection)
 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 from_tensor_;
  ::google::protobuf::internal::ArenaStringPtr to_tensor_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class CallableOptions_FeedDevicesEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<CallableOptions_FeedDevicesEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::google::protobuf::internal::MapEntry<CallableOptions_FeedDevicesEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  CallableOptions_FeedDevicesEntry_DoNotUse();
  CallableOptions_FeedDevicesEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const CallableOptions_FeedDevicesEntry_DoNotUse& other);
  static const CallableOptions_FeedDevicesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CallableOptions_FeedDevicesEntry_DoNotUse*>(&_CallableOptions_FeedDevicesEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

class CallableOptions_FetchDevicesEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<CallableOptions_FetchDevicesEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::google::protobuf::internal::MapEntry<CallableOptions_FetchDevicesEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  CallableOptions_FetchDevicesEntry_DoNotUse();
  CallableOptions_FetchDevicesEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const CallableOptions_FetchDevicesEntry_DoNotUse& other);
  static const CallableOptions_FetchDevicesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CallableOptions_FetchDevicesEntry_DoNotUse*>(&_CallableOptions_FetchDevicesEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

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

  CallableOptions(const CallableOptions& from);

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CallableOptions* internal_default_instance() {
    return reinterpret_cast<const CallableOptions*>(
               &_CallableOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

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

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

  inline CallableOptions* New() const final {
    return CreateMaybeMessage<CallableOptions>(NULL);
  }

  CallableOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CallableOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CallableOptions& from);
  void MergeFrom(const CallableOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CallableOptions* other);
  protected:
  explicit CallableOptions(::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 final;

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


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

  // repeated string feed = 1;
  int feed_size() const;
  void clear_feed();
  static const int kFeedFieldNumber = 1;
  const ::std::string& feed(int index) const;
  ::std::string* mutable_feed(int index);
  void set_feed(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_feed(int index, ::std::string&& value);
  #endif
  void set_feed(int index, const char* value);
  void set_feed(int index, const char* value, size_t size);
  ::std::string* add_feed();
  void add_feed(const ::std::string& value);
  #if LANG_CXX11
  void add_feed(::std::string&& value);
  #endif
  void add_feed(const char* value);
  void add_feed(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& feed() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_feed();

  // repeated string fetch = 2;
  int fetch_size() const;
  void clear_fetch();
  static const int kFetchFieldNumber = 2;
  const ::std::string& fetch(int index) const;
  ::std::string* mutable_fetch(int index);
  void set_fetch(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_fetch(int index, ::std::string&& value);
  #endif
  void set_fetch(int index, const char* value);
  void set_fetch(int index, const char* value, size_t size);
  ::std::string* add_fetch();
  void add_fetch(const ::std::string& value);
  #if LANG_CXX11
  void add_fetch(::std::string&& value);
  #endif
  void add_fetch(const char* value);
  void add_fetch(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& fetch() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_fetch();

  // repeated string target = 3;
  int target_size() const;
  void clear_target();
  static const int kTargetFieldNumber = 3;
  const ::std::string& target(int index) const;
  ::std::string* mutable_target(int index);
  void set_target(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_target(int index, ::std::string&& value);
  #endif
  void set_target(int index, const char* value);
  void set_target(int index, const char* value, size_t size);
  ::std::string* add_target();
  void add_target(const ::std::string& value);
  #if LANG_CXX11
  void add_target(::std::string&& value);
  #endif
  void add_target(const char* value);
  void add_target(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& target() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_target();

  // repeated .tensorflow.TensorConnection tensor_connection = 5;
  int tensor_connection_size() const;
  void clear_tensor_connection();
  static const int kTensorConnectionFieldNumber = 5;
  ::tensorflow::TensorConnection* mutable_tensor_connection(int index);
  ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorConnection >*
      mutable_tensor_connection();
  const ::tensorflow::TensorConnection& tensor_connection(int index) const;
  ::tensorflow::TensorConnection* add_tensor_connection();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorConnection >&
      tensor_connection() const;

  // map<string, string> feed_devices = 6;
  int feed_devices_size() const;
  void clear_feed_devices();
  static const int kFeedDevicesFieldNumber = 6;
  const ::google::protobuf::Map< ::std::string, ::std::string >&
      feed_devices() const;
  ::google::protobuf::Map< ::std::string, ::std::string >*
      mutable_feed_devices();

  // map<string, string> fetch_devices = 7;
  int fetch_devices_size() const;
  void clear_fetch_devices();
  static const int kFetchDevicesFieldNumber = 7;
  const ::google::protobuf::Map< ::std::string, ::std::string >&
      fetch_devices() const;
  ::google::protobuf::Map< ::std::string, ::std::string >*
      mutable_fetch_devices();

  // .tensorflow.RunOptions run_options = 4;
  bool has_run_options() const;
  void clear_run_options();
  static const int kRunOptionsFieldNumber = 4;
  private:
  const ::tensorflow::RunOptions& _internal_run_options() const;
  public:
  const ::tensorflow::RunOptions& run_options() const;
  ::tensorflow::RunOptions* release_run_options();
  ::tensorflow::RunOptions* mutable_run_options();
  void set_allocated_run_options(::tensorflow::RunOptions* run_options);
  void unsafe_arena_set_allocated_run_options(
      ::tensorflow::RunOptions* run_options);
  ::tensorflow::RunOptions* unsafe_arena_release_run_options();

  // bool fetch_skip_sync = 8;
  void clear_fetch_skip_sync();
  static const int kFetchSkipSyncFieldNumber = 8;
  bool fetch_skip_sync() const;
  void set_fetch_skip_sync(bool value);

  // @@protoc_insertion_point(class_scope:tensorflow.CallableOptions)
 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< ::std::string> feed_;
  ::google::protobuf::RepeatedPtrField< ::std::string> fetch_;
  ::google::protobuf::RepeatedPtrField< ::std::string> target_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorConnection > tensor_connection_;
  ::google::protobuf::internal::MapField<
      CallableOptions_FeedDevicesEntry_DoNotUse,
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > feed_devices_;
  ::google::protobuf::internal::MapField<
      CallableOptions_FetchDevicesEntry_DoNotUse,
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > fetch_devices_;
  ::tensorflow::RunOptions* run_options_;
  bool fetch_skip_sync_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto::TableStruct;
};
// ===================================================================


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

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

// repeated float memory_limit_mb = 1;
inline int GPUOptions_Experimental_VirtualDevices::memory_limit_mb_size() const {
  return memory_limit_mb_.size();
}
inline void GPUOptions_Experimental_VirtualDevices::clear_memory_limit_mb() {
  memory_limit_mb_.Clear();
}
inline float GPUOptions_Experimental_VirtualDevices::memory_limit_mb(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.Experimental.VirtualDevices.memory_limit_mb)
  return memory_limit_mb_.Get(index);
}
inline void GPUOptions_Experimental_VirtualDevices::set_memory_limit_mb(int index, float value) {
  memory_limit_mb_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.Experimental.VirtualDevices.memory_limit_mb)
}
inline void GPUOptions_Experimental_VirtualDevices::add_memory_limit_mb(float value) {
  memory_limit_mb_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.GPUOptions.Experimental.VirtualDevices.memory_limit_mb)
}
inline const ::google::protobuf::RepeatedField< float >&
GPUOptions_Experimental_VirtualDevices::memory_limit_mb() const {
  // @@protoc_insertion_point(field_list:tensorflow.GPUOptions.Experimental.VirtualDevices.memory_limit_mb)
  return memory_limit_mb_;
}
inline ::google::protobuf::RepeatedField< float >*
GPUOptions_Experimental_VirtualDevices::mutable_memory_limit_mb() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.GPUOptions.Experimental.VirtualDevices.memory_limit_mb)
  return &memory_limit_mb_;
}

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

// GPUOptions_Experimental

// repeated .tensorflow.GPUOptions.Experimental.VirtualDevices virtual_devices = 1;
inline int GPUOptions_Experimental::virtual_devices_size() const {
  return virtual_devices_.size();
}
inline void GPUOptions_Experimental::clear_virtual_devices() {
  virtual_devices_.Clear();
}
inline ::tensorflow::GPUOptions_Experimental_VirtualDevices* GPUOptions_Experimental::mutable_virtual_devices(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.Experimental.virtual_devices)
  return virtual_devices_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::GPUOptions_Experimental_VirtualDevices >*
GPUOptions_Experimental::mutable_virtual_devices() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.GPUOptions.Experimental.virtual_devices)
  return &virtual_devices_;
}
inline const ::tensorflow::GPUOptions_Experimental_VirtualDevices& GPUOptions_Experimental::virtual_devices(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.Experimental.virtual_devices)
  return virtual_devices_.Get(index);
}
inline ::tensorflow::GPUOptions_Experimental_VirtualDevices* GPUOptions_Experimental::add_virtual_devices() {
  // @@protoc_insertion_point(field_add:tensorflow.GPUOptions.Experimental.virtual_devices)
  return virtual_devices_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::GPUOptions_Experimental_VirtualDevices >&
GPUOptions_Experimental::virtual_devices() const {
  // @@protoc_insertion_point(field_list:tensorflow.GPUOptions.Experimental.virtual_devices)
  return virtual_devices_;
}

// bool use_unified_memory = 2;
inline void GPUOptions_Experimental::clear_use_unified_memory() {
  use_unified_memory_ = false;
}
inline bool GPUOptions_Experimental::use_unified_memory() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.Experimental.use_unified_memory)
  return use_unified_memory_;
}
inline void GPUOptions_Experimental::set_use_unified_memory(bool value) {
  
  use_unified_memory_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.Experimental.use_unified_memory)
}

// int32 num_dev_to_dev_copy_streams = 3;
inline void GPUOptions_Experimental::clear_num_dev_to_dev_copy_streams() {
  num_dev_to_dev_copy_streams_ = 0;
}
inline ::google::protobuf::int32 GPUOptions_Experimental::num_dev_to_dev_copy_streams() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.Experimental.num_dev_to_dev_copy_streams)
  return num_dev_to_dev_copy_streams_;
}
inline void GPUOptions_Experimental::set_num_dev_to_dev_copy_streams(::google::protobuf::int32 value) {
  
  num_dev_to_dev_copy_streams_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.GPUOptions.Experimental.num_dev_to_dev_copy_streams)
}

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

// 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)
}

// 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 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 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 ::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::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)
}

// 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 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 ::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::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)
}

// .tensorflow.GPUOptions.Experimental experimental = 9;
inline bool GPUOptions::has_experimental() const {
  return this != internal_default_instance() && experimental_ != NULL;
}
inline void GPUOptions::clear_experimental() {
  if (GetArenaNoVirtual() == NULL && experimental_ != NULL) {
    delete experimental_;
  }
  experimental_ = NULL;
}
inline const ::tensorflow::GPUOptions_Experimental& GPUOptions::_internal_experimental() const {
  return *experimental_;
}
inline const ::tensorflow::GPUOptions_Experimental& GPUOptions::experimental() const {
  const ::tensorflow::GPUOptions_Experimental* p = experimental_;
  // @@protoc_insertion_point(field_get:tensorflow.GPUOptions.experimental)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::GPUOptions_Experimental*>(
      &::tensorflow::_GPUOptions_Experimental_default_instance_);
}
inline ::tensorflow::GPUOptions_Experimental* GPUOptions::release_experimental() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUOptions.experimental)
  
  ::tensorflow::GPUOptions_Experimental* temp = experimental_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::GPUOptions_Experimental* GPUOptions::unsafe_arena_release_experimental() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUOptions.experimental)
  
  ::tensorflow::GPUOptions_Experimental* temp = experimental_;
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::GPUOptions_Experimental* GPUOptions::mutable_experimental() {
  
  if (experimental_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::GPUOptions_Experimental>(GetArenaNoVirtual());
    experimental_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.experimental)
  return experimental_;
}
inline void GPUOptions::set_allocated_experimental(::tensorflow::GPUOptions_Experimental* experimental) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete experimental_;
  }
  if (experimental) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(experimental);
    if (message_arena != submessage_arena) {
      experimental = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, experimental, submessage_arena);
    }
    
  } else {
    
  }
  experimental_ = experimental;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUOptions.experimental)
}

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

// 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)
}

// int64 max_folded_constant_in_bytes = 6;
inline void OptimizerOptions::clear_max_folded_constant_in_bytes() {
  max_folded_constant_in_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 OptimizerOptions::max_folded_constant_in_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.OptimizerOptions.max_folded_constant_in_bytes)
  return max_folded_constant_in_bytes_;
}
inline void OptimizerOptions::set_max_folded_constant_in_bytes(::google::protobuf::int64 value) {
  
  max_folded_constant_in_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.OptimizerOptions.max_folded_constant_in_bytes)
}

// 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::_internal_optimizer_options() const {
  return *optimizer_options_;
}
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::release_optimizer_options() {
  // @@protoc_insertion_point(field_release:tensorflow.GraphOptions.optimizer_options)
  
  ::tensorflow::OptimizerOptions* temp = optimizer_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optimizer_options_ = NULL;
  return temp;
}
inline ::tensorflow::OptimizerOptions* GraphOptions::unsafe_arena_release_optimizer_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOptions.optimizer_options)
  
  ::tensorflow::OptimizerOptions* temp = optimizer_options_;
  optimizer_options_ = NULL;
  return temp;
}
inline ::tensorflow::OptimizerOptions* GraphOptions::mutable_optimizer_options() {
  
  if (optimizer_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::OptimizerOptions>(GetArenaNoVirtual());
    optimizer_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.GraphOptions.optimizer_options)
  return optimizer_options_;
}
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) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optimizer_options);
    if (message_arena != submessage_arena) {
      optimizer_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optimizer_options, submessage_arena);
    }
    
  } else {
    
  }
  optimizer_options_ = optimizer_options;
  // @@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 const ::tensorflow::RewriterConfig& GraphOptions::_internal_rewrite_options() const {
  return *rewrite_options_;
}
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::release_rewrite_options() {
  // @@protoc_insertion_point(field_release:tensorflow.GraphOptions.rewrite_options)
  
  ::tensorflow::RewriterConfig* temp = rewrite_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  rewrite_options_ = NULL;
  return temp;
}
inline ::tensorflow::RewriterConfig* GraphOptions::unsafe_arena_release_rewrite_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOptions.rewrite_options)
  
  ::tensorflow::RewriterConfig* temp = rewrite_options_;
  rewrite_options_ = NULL;
  return temp;
}
inline ::tensorflow::RewriterConfig* GraphOptions::mutable_rewrite_options() {
  
  if (rewrite_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::RewriterConfig>(GetArenaNoVirtual());
    rewrite_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.GraphOptions.rewrite_options)
  return rewrite_options_;
}
inline void GraphOptions::set_allocated_rewrite_options(::tensorflow::RewriterConfig* rewrite_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(rewrite_options_);
  }
  if (rewrite_options) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(rewrite_options)->GetArena();
    if (message_arena != submessage_arena) {
      rewrite_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, rewrite_options, submessage_arena);
    }
    
  } else {
    
  }
  rewrite_options_ = rewrite_options;
  // @@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 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 ::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::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_Experimental

// string collective_group_leader = 1;
inline void ConfigProto_Experimental::clear_collective_group_leader() {
  collective_group_leader_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& ConfigProto_Experimental::collective_group_leader() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.Experimental.collective_group_leader)
  return collective_group_leader_.Get();
}
inline void ConfigProto_Experimental::set_collective_group_leader(const ::std::string& value) {
  
  collective_group_leader_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.Experimental.collective_group_leader)
}
#if LANG_CXX11
inline void ConfigProto_Experimental::set_collective_group_leader(::std::string&& value) {
  
  collective_group_leader_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.ConfigProto.Experimental.collective_group_leader)
}
#endif
inline void ConfigProto_Experimental::set_collective_group_leader(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  collective_group_leader_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.ConfigProto.Experimental.collective_group_leader)
}
inline void ConfigProto_Experimental::set_collective_group_leader(const char* value,
    size_t size) {
  
  collective_group_leader_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.ConfigProto.Experimental.collective_group_leader)
}
inline ::std::string* ConfigProto_Experimental::mutable_collective_group_leader() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.Experimental.collective_group_leader)
  return collective_group_leader_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* ConfigProto_Experimental::release_collective_group_leader() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.Experimental.collective_group_leader)
  
  return collective_group_leader_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void ConfigProto_Experimental::set_allocated_collective_group_leader(::std::string* collective_group_leader) {
  if (collective_group_leader != NULL) {
    
  } else {
    
  }
  collective_group_leader_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), collective_group_leader,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.Experimental.collective_group_leader)
}
inline ::std::string* ConfigProto_Experimental::unsafe_arena_release_collective_group_leader() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.Experimental.collective_group_leader)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return collective_group_leader_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void ConfigProto_Experimental::unsafe_arena_set_allocated_collective_group_leader(
    ::std::string* collective_group_leader) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (collective_group_leader != NULL) {
    
  } else {
    
  }
  collective_group_leader_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      collective_group_leader, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ConfigProto.Experimental.collective_group_leader)
}

// string executor_type = 3;
inline void ConfigProto_Experimental::clear_executor_type() {
  executor_type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& ConfigProto_Experimental::executor_type() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.Experimental.executor_type)
  return executor_type_.Get();
}
inline void ConfigProto_Experimental::set_executor_type(const ::std::string& value) {
  
  executor_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.Experimental.executor_type)
}
#if LANG_CXX11
inline void ConfigProto_Experimental::set_executor_type(::std::string&& value) {
  
  executor_type_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.ConfigProto.Experimental.executor_type)
}
#endif
inline void ConfigProto_Experimental::set_executor_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  executor_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.ConfigProto.Experimental.executor_type)
}
inline void ConfigProto_Experimental::set_executor_type(const char* value,
    size_t size) {
  
  executor_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.ConfigProto.Experimental.executor_type)
}
inline ::std::string* ConfigProto_Experimental::mutable_executor_type() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.Experimental.executor_type)
  return executor_type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* ConfigProto_Experimental::release_executor_type() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.Experimental.executor_type)
  
  return executor_type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void ConfigProto_Experimental::set_allocated_executor_type(::std::string* executor_type) {
  if (executor_type != NULL) {
    
  } else {
    
  }
  executor_type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), executor_type,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.Experimental.executor_type)
}
inline ::std::string* ConfigProto_Experimental::unsafe_arena_release_executor_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.Experimental.executor_type)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return executor_type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void ConfigProto_Experimental::unsafe_arena_set_allocated_executor_type(
    ::std::string* executor_type) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (executor_type != NULL) {
    
  } else {
    
  }
  executor_type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      executor_type, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ConfigProto.Experimental.executor_type)
}

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

// 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 ::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 ::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 ::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::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 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::_internal_gpu_options() const {
  return *gpu_options_;
}
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::release_gpu_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.gpu_options)
  
  ::tensorflow::GPUOptions* temp = gpu_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  gpu_options_ = NULL;
  return temp;
}
inline ::tensorflow::GPUOptions* ConfigProto::unsafe_arena_release_gpu_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.gpu_options)
  
  ::tensorflow::GPUOptions* temp = gpu_options_;
  gpu_options_ = NULL;
  return temp;
}
inline ::tensorflow::GPUOptions* ConfigProto::mutable_gpu_options() {
  
  if (gpu_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::GPUOptions>(GetArenaNoVirtual());
    gpu_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.gpu_options)
  return gpu_options_;
}
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) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(gpu_options);
    if (message_arena != submessage_arena) {
      gpu_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, gpu_options, submessage_arena);
    }
    
  } else {
    
  }
  gpu_options_ = gpu_options;
  // @@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::_internal_graph_options() const {
  return *graph_options_;
}
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::release_graph_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.graph_options)
  
  ::tensorflow::GraphOptions* temp = graph_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  graph_options_ = NULL;
  return temp;
}
inline ::tensorflow::GraphOptions* ConfigProto::unsafe_arena_release_graph_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.graph_options)
  
  ::tensorflow::GraphOptions* temp = graph_options_;
  graph_options_ = NULL;
  return temp;
}
inline ::tensorflow::GraphOptions* ConfigProto::mutable_graph_options() {
  
  if (graph_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::GraphOptions>(GetArenaNoVirtual());
    graph_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.graph_options)
  return graph_options_;
}
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) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(graph_options);
    if (message_arena != submessage_arena) {
      graph_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, graph_options, submessage_arena);
    }
    
  } else {
    
  }
  graph_options_ = graph_options;
  // @@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::_internal_rpc_options() const {
  return *rpc_options_;
}
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::release_rpc_options() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.rpc_options)
  
  ::tensorflow::RPCOptions* temp = rpc_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  rpc_options_ = NULL;
  return temp;
}
inline ::tensorflow::RPCOptions* ConfigProto::unsafe_arena_release_rpc_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.rpc_options)
  
  ::tensorflow::RPCOptions* temp = rpc_options_;
  rpc_options_ = NULL;
  return temp;
}
inline ::tensorflow::RPCOptions* ConfigProto::mutable_rpc_options() {
  
  if (rpc_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::RPCOptions>(GetArenaNoVirtual());
    rpc_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.rpc_options)
  return rpc_options_;
}
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) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(rpc_options);
    if (message_arena != submessage_arena) {
      rpc_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, rpc_options, submessage_arena);
    }
    
  } else {
    
  }
  rpc_options_ = rpc_options;
  // @@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 const ::tensorflow::ClusterDef& ConfigProto::_internal_cluster_def() const {
  return *cluster_def_;
}
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::release_cluster_def() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.cluster_def)
  
  ::tensorflow::ClusterDef* temp = cluster_def_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  cluster_def_ = NULL;
  return temp;
}
inline ::tensorflow::ClusterDef* ConfigProto::unsafe_arena_release_cluster_def() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.cluster_def)
  
  ::tensorflow::ClusterDef* temp = cluster_def_;
  cluster_def_ = NULL;
  return temp;
}
inline ::tensorflow::ClusterDef* ConfigProto::mutable_cluster_def() {
  
  if (cluster_def_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::ClusterDef>(GetArenaNoVirtual());
    cluster_def_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.cluster_def)
  return cluster_def_;
}
inline void ConfigProto::set_allocated_cluster_def(::tensorflow::ClusterDef* cluster_def) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(cluster_def_);
  }
  if (cluster_def) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(cluster_def)->GetArena();
    if (message_arena != submessage_arena) {
      cluster_def = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, cluster_def, submessage_arena);
    }
    
  } else {
    
  }
  cluster_def_ = cluster_def;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.cluster_def)
}

// bool isolate_session_state = 15;
inline void ConfigProto::clear_isolate_session_state() {
  isolate_session_state_ = false;
}
inline bool ConfigProto::isolate_session_state() const {
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.isolate_session_state)
  return isolate_session_state_;
}
inline void ConfigProto::set_isolate_session_state(bool value) {
  
  isolate_session_state_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.ConfigProto.isolate_session_state)
}

// .tensorflow.ConfigProto.Experimental experimental = 16;
inline bool ConfigProto::has_experimental() const {
  return this != internal_default_instance() && experimental_ != NULL;
}
inline void ConfigProto::clear_experimental() {
  if (GetArenaNoVirtual() == NULL && experimental_ != NULL) {
    delete experimental_;
  }
  experimental_ = NULL;
}
inline const ::tensorflow::ConfigProto_Experimental& ConfigProto::_internal_experimental() const {
  return *experimental_;
}
inline const ::tensorflow::ConfigProto_Experimental& ConfigProto::experimental() const {
  const ::tensorflow::ConfigProto_Experimental* p = experimental_;
  // @@protoc_insertion_point(field_get:tensorflow.ConfigProto.experimental)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::ConfigProto_Experimental*>(
      &::tensorflow::_ConfigProto_Experimental_default_instance_);
}
inline ::tensorflow::ConfigProto_Experimental* ConfigProto::release_experimental() {
  // @@protoc_insertion_point(field_release:tensorflow.ConfigProto.experimental)
  
  ::tensorflow::ConfigProto_Experimental* temp = experimental_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::ConfigProto_Experimental* ConfigProto::unsafe_arena_release_experimental() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ConfigProto.experimental)
  
  ::tensorflow::ConfigProto_Experimental* temp = experimental_;
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::ConfigProto_Experimental* ConfigProto::mutable_experimental() {
  
  if (experimental_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::ConfigProto_Experimental>(GetArenaNoVirtual());
    experimental_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.ConfigProto.experimental)
  return experimental_;
}
inline void ConfigProto::set_allocated_experimental(::tensorflow::ConfigProto_Experimental* experimental) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete experimental_;
  }
  if (experimental) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(experimental);
    if (message_arena != submessage_arena) {
      experimental = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, experimental, submessage_arena);
    }
    
  } else {
    
  }
  experimental_ = experimental;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.ConfigProto.experimental)
}

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

// RunOptions_Experimental

// int64 collective_graph_key = 1;
inline void RunOptions_Experimental::clear_collective_graph_key() {
  collective_graph_key_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RunOptions_Experimental::collective_graph_key() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.Experimental.collective_graph_key)
  return collective_graph_key_;
}
inline void RunOptions_Experimental::set_collective_graph_key(::google::protobuf::int64 value) {
  
  collective_graph_key_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.Experimental.collective_graph_key)
}

// bool use_run_handler_pool = 2;
inline void RunOptions_Experimental::clear_use_run_handler_pool() {
  use_run_handler_pool_ = false;
}
inline bool RunOptions_Experimental::use_run_handler_pool() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.Experimental.use_run_handler_pool)
  return use_run_handler_pool_;
}
inline void RunOptions_Experimental::set_use_run_handler_pool(bool value) {
  
  use_run_handler_pool_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.Experimental.use_run_handler_pool)
}

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

// 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 const ::tensorflow::DebugOptions& RunOptions::_internal_debug_options() const {
  return *debug_options_;
}
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::release_debug_options() {
  // @@protoc_insertion_point(field_release:tensorflow.RunOptions.debug_options)
  
  ::tensorflow::DebugOptions* temp = debug_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  debug_options_ = NULL;
  return temp;
}
inline ::tensorflow::DebugOptions* RunOptions::unsafe_arena_release_debug_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.RunOptions.debug_options)
  
  ::tensorflow::DebugOptions* temp = debug_options_;
  debug_options_ = NULL;
  return temp;
}
inline ::tensorflow::DebugOptions* RunOptions::mutable_debug_options() {
  
  if (debug_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::DebugOptions>(GetArenaNoVirtual());
    debug_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunOptions.debug_options)
  return debug_options_;
}
inline void RunOptions::set_allocated_debug_options(::tensorflow::DebugOptions* debug_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(debug_options_);
  }
  if (debug_options) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(debug_options)->GetArena();
    if (message_arena != submessage_arena) {
      debug_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, debug_options, submessage_arena);
    }
    
  } else {
    
  }
  debug_options_ = debug_options;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.RunOptions.debug_options)
}

// bool report_tensor_allocations_upon_oom = 7;
inline void RunOptions::clear_report_tensor_allocations_upon_oom() {
  report_tensor_allocations_upon_oom_ = false;
}
inline bool RunOptions::report_tensor_allocations_upon_oom() const {
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.report_tensor_allocations_upon_oom)
  return report_tensor_allocations_upon_oom_;
}
inline void RunOptions::set_report_tensor_allocations_upon_oom(bool value) {
  
  report_tensor_allocations_upon_oom_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.RunOptions.report_tensor_allocations_upon_oom)
}

// .tensorflow.RunOptions.Experimental experimental = 8;
inline bool RunOptions::has_experimental() const {
  return this != internal_default_instance() && experimental_ != NULL;
}
inline void RunOptions::clear_experimental() {
  if (GetArenaNoVirtual() == NULL && experimental_ != NULL) {
    delete experimental_;
  }
  experimental_ = NULL;
}
inline const ::tensorflow::RunOptions_Experimental& RunOptions::_internal_experimental() const {
  return *experimental_;
}
inline const ::tensorflow::RunOptions_Experimental& RunOptions::experimental() const {
  const ::tensorflow::RunOptions_Experimental* p = experimental_;
  // @@protoc_insertion_point(field_get:tensorflow.RunOptions.experimental)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::RunOptions_Experimental*>(
      &::tensorflow::_RunOptions_Experimental_default_instance_);
}
inline ::tensorflow::RunOptions_Experimental* RunOptions::release_experimental() {
  // @@protoc_insertion_point(field_release:tensorflow.RunOptions.experimental)
  
  ::tensorflow::RunOptions_Experimental* temp = experimental_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::RunOptions_Experimental* RunOptions::unsafe_arena_release_experimental() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.RunOptions.experimental)
  
  ::tensorflow::RunOptions_Experimental* temp = experimental_;
  experimental_ = NULL;
  return temp;
}
inline ::tensorflow::RunOptions_Experimental* RunOptions::mutable_experimental() {
  
  if (experimental_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::RunOptions_Experimental>(GetArenaNoVirtual());
    experimental_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunOptions.experimental)
  return experimental_;
}
inline void RunOptions::set_allocated_experimental(::tensorflow::RunOptions_Experimental* experimental) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete experimental_;
  }
  if (experimental) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(experimental);
    if (message_arena != submessage_arena) {
      experimental = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, experimental, submessage_arena);
    }
    
  } else {
    
  }
  experimental_ = experimental;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.RunOptions.experimental)
}

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

// RunMetadata

// .tensorflow.StepStats step_stats = 1;
inline bool RunMetadata::has_step_stats() const {
  return this != internal_default_instance() && step_stats_ != NULL;
}
inline const ::tensorflow::StepStats& RunMetadata::_internal_step_stats() const {
  return *step_stats_;
}
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::release_step_stats() {
  // @@protoc_insertion_point(field_release:tensorflow.RunMetadata.step_stats)
  
  ::tensorflow::StepStats* temp = step_stats_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  step_stats_ = NULL;
  return temp;
}
inline ::tensorflow::StepStats* RunMetadata::unsafe_arena_release_step_stats() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.RunMetadata.step_stats)
  
  ::tensorflow::StepStats* temp = step_stats_;
  step_stats_ = NULL;
  return temp;
}
inline ::tensorflow::StepStats* RunMetadata::mutable_step_stats() {
  
  if (step_stats_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::StepStats>(GetArenaNoVirtual());
    step_stats_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.step_stats)
  return step_stats_;
}
inline void RunMetadata::set_allocated_step_stats(::tensorflow::StepStats* step_stats) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(step_stats_);
  }
  if (step_stats) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(step_stats)->GetArena();
    if (message_arena != submessage_arena) {
      step_stats = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, step_stats, submessage_arena);
    }
    
  } else {
    
  }
  step_stats_ = step_stats;
  // @@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 const ::tensorflow::CostGraphDef& RunMetadata::_internal_cost_graph() const {
  return *cost_graph_;
}
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::release_cost_graph() {
  // @@protoc_insertion_point(field_release:tensorflow.RunMetadata.cost_graph)
  
  ::tensorflow::CostGraphDef* temp = cost_graph_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  cost_graph_ = NULL;
  return temp;
}
inline ::tensorflow::CostGraphDef* RunMetadata::unsafe_arena_release_cost_graph() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.RunMetadata.cost_graph)
  
  ::tensorflow::CostGraphDef* temp = cost_graph_;
  cost_graph_ = NULL;
  return temp;
}
inline ::tensorflow::CostGraphDef* RunMetadata::mutable_cost_graph() {
  
  if (cost_graph_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::CostGraphDef>(GetArenaNoVirtual());
    cost_graph_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.cost_graph)
  return cost_graph_;
}
inline void RunMetadata::set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(cost_graph_);
  }
  if (cost_graph) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(cost_graph)->GetArena();
    if (message_arena != submessage_arena) {
      cost_graph = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, cost_graph, submessage_arena);
    }
    
  } else {
    
  }
  cost_graph_ = cost_graph;
  // @@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 ::tensorflow::GraphDef* RunMetadata::mutable_partition_graphs(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_.Mutable(index);
}
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 ::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::add_partition_graphs() {
  // @@protoc_insertion_point(field_add:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef >&
RunMetadata::partition_graphs() const {
  // @@protoc_insertion_point(field_list:tensorflow.RunMetadata.partition_graphs)
  return partition_graphs_;
}

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

// TensorConnection

// string from_tensor = 1;
inline void TensorConnection::clear_from_tensor() {
  from_tensor_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& TensorConnection::from_tensor() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorConnection.from_tensor)
  return from_tensor_.Get();
}
inline void TensorConnection::set_from_tensor(const ::std::string& value) {
  
  from_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.TensorConnection.from_tensor)
}
#if LANG_CXX11
inline void TensorConnection::set_from_tensor(::std::string&& value) {
  
  from_tensor_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.TensorConnection.from_tensor)
}
#endif
inline void TensorConnection::set_from_tensor(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  from_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.TensorConnection.from_tensor)
}
inline void TensorConnection::set_from_tensor(const char* value,
    size_t size) {
  
  from_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorConnection.from_tensor)
}
inline ::std::string* TensorConnection::mutable_from_tensor() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.TensorConnection.from_tensor)
  return from_tensor_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TensorConnection::release_from_tensor() {
  // @@protoc_insertion_point(field_release:tensorflow.TensorConnection.from_tensor)
  
  return from_tensor_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TensorConnection::set_allocated_from_tensor(::std::string* from_tensor) {
  if (from_tensor != NULL) {
    
  } else {
    
  }
  from_tensor_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from_tensor,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorConnection.from_tensor)
}
inline ::std::string* TensorConnection::unsafe_arena_release_from_tensor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorConnection.from_tensor)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return from_tensor_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TensorConnection::unsafe_arena_set_allocated_from_tensor(
    ::std::string* from_tensor) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (from_tensor != NULL) {
    
  } else {
    
  }
  from_tensor_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      from_tensor, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorConnection.from_tensor)
}

// string to_tensor = 2;
inline void TensorConnection::clear_to_tensor() {
  to_tensor_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& TensorConnection::to_tensor() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorConnection.to_tensor)
  return to_tensor_.Get();
}
inline void TensorConnection::set_to_tensor(const ::std::string& value) {
  
  to_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.TensorConnection.to_tensor)
}
#if LANG_CXX11
inline void TensorConnection::set_to_tensor(::std::string&& value) {
  
  to_tensor_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.TensorConnection.to_tensor)
}
#endif
inline void TensorConnection::set_to_tensor(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  to_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.TensorConnection.to_tensor)
}
inline void TensorConnection::set_to_tensor(const char* value,
    size_t size) {
  
  to_tensor_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorConnection.to_tensor)
}
inline ::std::string* TensorConnection::mutable_to_tensor() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.TensorConnection.to_tensor)
  return to_tensor_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TensorConnection::release_to_tensor() {
  // @@protoc_insertion_point(field_release:tensorflow.TensorConnection.to_tensor)
  
  return to_tensor_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TensorConnection::set_allocated_to_tensor(::std::string* to_tensor) {
  if (to_tensor != NULL) {
    
  } else {
    
  }
  to_tensor_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to_tensor,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorConnection.to_tensor)
}
inline ::std::string* TensorConnection::unsafe_arena_release_to_tensor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorConnection.to_tensor)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return to_tensor_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TensorConnection::unsafe_arena_set_allocated_to_tensor(
    ::std::string* to_tensor) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (to_tensor != NULL) {
    
  } else {
    
  }
  to_tensor_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      to_tensor, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorConnection.to_tensor)
}

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

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

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

// CallableOptions

// repeated string feed = 1;
inline int CallableOptions::feed_size() const {
  return feed_.size();
}
inline void CallableOptions::clear_feed() {
  feed_.Clear();
}
inline const ::std::string& CallableOptions::feed(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.feed)
  return feed_.Get(index);
}
inline ::std::string* CallableOptions::mutable_feed(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.CallableOptions.feed)
  return feed_.Mutable(index);
}
inline void CallableOptions::set_feed(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.feed)
  feed_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void CallableOptions::set_feed(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.feed)
  feed_.Mutable(index)->assign(std::move(value));
}
#endif
inline void CallableOptions::set_feed(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  feed_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.CallableOptions.feed)
}
inline void CallableOptions::set_feed(int index, const char* value, size_t size) {
  feed_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.CallableOptions.feed)
}
inline ::std::string* CallableOptions::add_feed() {
  // @@protoc_insertion_point(field_add_mutable:tensorflow.CallableOptions.feed)
  return feed_.Add();
}
inline void CallableOptions::add_feed(const ::std::string& value) {
  feed_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.feed)
}
#if LANG_CXX11
inline void CallableOptions::add_feed(::std::string&& value) {
  feed_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.feed)
}
#endif
inline void CallableOptions::add_feed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  feed_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.CallableOptions.feed)
}
inline void CallableOptions::add_feed(const char* value, size_t size) {
  feed_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.CallableOptions.feed)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
CallableOptions::feed() const {
  // @@protoc_insertion_point(field_list:tensorflow.CallableOptions.feed)
  return feed_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
CallableOptions::mutable_feed() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.CallableOptions.feed)
  return &feed_;
}

// repeated string fetch = 2;
inline int CallableOptions::fetch_size() const {
  return fetch_.size();
}
inline void CallableOptions::clear_fetch() {
  fetch_.Clear();
}
inline const ::std::string& CallableOptions::fetch(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.fetch)
  return fetch_.Get(index);
}
inline ::std::string* CallableOptions::mutable_fetch(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.CallableOptions.fetch)
  return fetch_.Mutable(index);
}
inline void CallableOptions::set_fetch(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.fetch)
  fetch_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void CallableOptions::set_fetch(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.fetch)
  fetch_.Mutable(index)->assign(std::move(value));
}
#endif
inline void CallableOptions::set_fetch(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  fetch_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.CallableOptions.fetch)
}
inline void CallableOptions::set_fetch(int index, const char* value, size_t size) {
  fetch_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.CallableOptions.fetch)
}
inline ::std::string* CallableOptions::add_fetch() {
  // @@protoc_insertion_point(field_add_mutable:tensorflow.CallableOptions.fetch)
  return fetch_.Add();
}
inline void CallableOptions::add_fetch(const ::std::string& value) {
  fetch_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.fetch)
}
#if LANG_CXX11
inline void CallableOptions::add_fetch(::std::string&& value) {
  fetch_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.fetch)
}
#endif
inline void CallableOptions::add_fetch(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  fetch_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.CallableOptions.fetch)
}
inline void CallableOptions::add_fetch(const char* value, size_t size) {
  fetch_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.CallableOptions.fetch)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
CallableOptions::fetch() const {
  // @@protoc_insertion_point(field_list:tensorflow.CallableOptions.fetch)
  return fetch_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
CallableOptions::mutable_fetch() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.CallableOptions.fetch)
  return &fetch_;
}

// repeated string target = 3;
inline int CallableOptions::target_size() const {
  return target_.size();
}
inline void CallableOptions::clear_target() {
  target_.Clear();
}
inline const ::std::string& CallableOptions::target(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.target)
  return target_.Get(index);
}
inline ::std::string* CallableOptions::mutable_target(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.CallableOptions.target)
  return target_.Mutable(index);
}
inline void CallableOptions::set_target(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.target)
  target_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void CallableOptions::set_target(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.target)
  target_.Mutable(index)->assign(std::move(value));
}
#endif
inline void CallableOptions::set_target(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  target_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.CallableOptions.target)
}
inline void CallableOptions::set_target(int index, const char* value, size_t size) {
  target_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.CallableOptions.target)
}
inline ::std::string* CallableOptions::add_target() {
  // @@protoc_insertion_point(field_add_mutable:tensorflow.CallableOptions.target)
  return target_.Add();
}
inline void CallableOptions::add_target(const ::std::string& value) {
  target_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.target)
}
#if LANG_CXX11
inline void CallableOptions::add_target(::std::string&& value) {
  target_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.target)
}
#endif
inline void CallableOptions::add_target(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  target_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.CallableOptions.target)
}
inline void CallableOptions::add_target(const char* value, size_t size) {
  target_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.CallableOptions.target)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
CallableOptions::target() const {
  // @@protoc_insertion_point(field_list:tensorflow.CallableOptions.target)
  return target_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
CallableOptions::mutable_target() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.CallableOptions.target)
  return &target_;
}

// .tensorflow.RunOptions run_options = 4;
inline bool CallableOptions::has_run_options() const {
  return this != internal_default_instance() && run_options_ != NULL;
}
inline void CallableOptions::clear_run_options() {
  if (GetArenaNoVirtual() == NULL && run_options_ != NULL) {
    delete run_options_;
  }
  run_options_ = NULL;
}
inline const ::tensorflow::RunOptions& CallableOptions::_internal_run_options() const {
  return *run_options_;
}
inline const ::tensorflow::RunOptions& CallableOptions::run_options() const {
  const ::tensorflow::RunOptions* p = run_options_;
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.run_options)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::RunOptions*>(
      &::tensorflow::_RunOptions_default_instance_);
}
inline ::tensorflow::RunOptions* CallableOptions::release_run_options() {
  // @@protoc_insertion_point(field_release:tensorflow.CallableOptions.run_options)
  
  ::tensorflow::RunOptions* temp = run_options_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  run_options_ = NULL;
  return temp;
}
inline ::tensorflow::RunOptions* CallableOptions::unsafe_arena_release_run_options() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CallableOptions.run_options)
  
  ::tensorflow::RunOptions* temp = run_options_;
  run_options_ = NULL;
  return temp;
}
inline ::tensorflow::RunOptions* CallableOptions::mutable_run_options() {
  
  if (run_options_ == NULL) {
    auto* p = CreateMaybeMessage<::tensorflow::RunOptions>(GetArenaNoVirtual());
    run_options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.CallableOptions.run_options)
  return run_options_;
}
inline void CallableOptions::set_allocated_run_options(::tensorflow::RunOptions* run_options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete run_options_;
  }
  if (run_options) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(run_options);
    if (message_arena != submessage_arena) {
      run_options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, run_options, submessage_arena);
    }
    
  } else {
    
  }
  run_options_ = run_options;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.CallableOptions.run_options)
}

// repeated .tensorflow.TensorConnection tensor_connection = 5;
inline int CallableOptions::tensor_connection_size() const {
  return tensor_connection_.size();
}
inline void CallableOptions::clear_tensor_connection() {
  tensor_connection_.Clear();
}
inline ::tensorflow::TensorConnection* CallableOptions::mutable_tensor_connection(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.CallableOptions.tensor_connection)
  return tensor_connection_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorConnection >*
CallableOptions::mutable_tensor_connection() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.CallableOptions.tensor_connection)
  return &tensor_connection_;
}
inline const ::tensorflow::TensorConnection& CallableOptions::tensor_connection(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.tensor_connection)
  return tensor_connection_.Get(index);
}
inline ::tensorflow::TensorConnection* CallableOptions::add_tensor_connection() {
  // @@protoc_insertion_point(field_add:tensorflow.CallableOptions.tensor_connection)
  return tensor_connection_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorConnection >&
CallableOptions::tensor_connection() const {
  // @@protoc_insertion_point(field_list:tensorflow.CallableOptions.tensor_connection)
  return tensor_connection_;
}

// map<string, string> feed_devices = 6;
inline int CallableOptions::feed_devices_size() const {
  return feed_devices_.size();
}
inline void CallableOptions::clear_feed_devices() {
  feed_devices_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::std::string >&
CallableOptions::feed_devices() const {
  // @@protoc_insertion_point(field_map:tensorflow.CallableOptions.feed_devices)
  return feed_devices_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::std::string >*
CallableOptions::mutable_feed_devices() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.CallableOptions.feed_devices)
  return feed_devices_.MutableMap();
}

// map<string, string> fetch_devices = 7;
inline int CallableOptions::fetch_devices_size() const {
  return fetch_devices_.size();
}
inline void CallableOptions::clear_fetch_devices() {
  fetch_devices_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::std::string >&
CallableOptions::fetch_devices() const {
  // @@protoc_insertion_point(field_map:tensorflow.CallableOptions.fetch_devices)
  return fetch_devices_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::std::string >*
CallableOptions::mutable_fetch_devices() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.CallableOptions.fetch_devices)
  return fetch_devices_.MutableMap();
}

// bool fetch_skip_sync = 8;
inline void CallableOptions::clear_fetch_skip_sync() {
  fetch_skip_sync_ = false;
}
inline bool CallableOptions::fetch_skip_sync() const {
  // @@protoc_insertion_point(field_get:tensorflow.CallableOptions.fetch_skip_sync)
  return fetch_skip_sync_;
}
inline void CallableOptions::set_fetch_skip_sync(bool value) {
  
  fetch_skip_sync_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.CallableOptions.fetch_skip_sync)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::tensorflow::OptimizerOptions_Level> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::OptimizerOptions_Level>() {
  return ::tensorflow::OptimizerOptions_Level_descriptor();
}
template <> struct is_proto_enum< ::tensorflow::OptimizerOptions_GlobalJitLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::OptimizerOptions_GlobalJitLevel>() {
  return ::tensorflow::OptimizerOptions_GlobalJitLevel_descriptor();
}
template <> struct is_proto_enum< ::tensorflow::RunOptions_TraceLevel> : ::std::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_INCLUDED_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto
