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

#ifndef PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED
#define PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3001000
#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 3001000 < 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/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/map.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"
// @@protoc_insertion_point(includes)

namespace tensorflow {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
void protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

class ConfigProto;
class GPUOptions;
class GraphOptions;
class OptimizerOptions;
class RPCOptions;
class RunMetadata;
class RunOptions;
class ThreadPoolOptionProto;

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

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

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

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

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

  GPUOptions(const GPUOptions& from);

  inline GPUOptions& operator=(const GPUOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GPUOptions& default_instance();

  static const GPUOptions* internal_default_instance();

  void UnsafeArenaSwap(GPUOptions* other);
  void Swap(GPUOptions* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GPUOptions* other);
  void UnsafeMergeFrom(const GPUOptions& from);
  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;

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

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

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

  // optional 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);
  void set_allocator_type(const char* value);
  void set_allocator_type(const char* value, size_t size);
  ::std::string* mutable_allocator_type();
  ::std::string* release_allocator_type();
  void set_allocated_allocator_type(::std::string* allocator_type);
  ::std::string* unsafe_arena_release_allocator_type();
  void unsafe_arena_set_allocated_allocator_type(
      ::std::string* allocator_type);

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

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

  // optional 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);
  void set_visible_device_list(const char* value);
  void set_visible_device_list(const char* value, size_t size);
  ::std::string* mutable_visible_device_list();
  ::std::string* release_visible_device_list();
  void set_allocated_visible_device_list(::std::string* visible_device_list);
  ::std::string* unsafe_arena_release_visible_device_list();
  void unsafe_arena_set_allocated_visible_device_list(
      ::std::string* visible_device_list);

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr allocator_type_;
  ::google::protobuf::internal::ArenaStringPtr visible_device_list_;
  double per_process_gpu_memory_fraction_;
  ::google::protobuf::int64 deferred_deletion_bytes_;
  bool allow_growth_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<GPUOptions> GPUOptions_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OptimizerOptions& default_instance();

  static const OptimizerOptions* internal_default_instance();

  void UnsafeArenaSwap(OptimizerOptions* other);
  void Swap(OptimizerOptions* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(OptimizerOptions* other);
  void UnsafeMergeFrom(const OptimizerOptions& from);
  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;

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

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

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

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

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

  // optional .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_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool do_common_subexpression_elimination_;
  bool do_constant_folding_;
  bool do_function_inlining_;
  int opt_level_;
  int global_jit_level_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<OptimizerOptions> OptimizerOptions_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const GraphOptions& default_instance();

  static const GraphOptions* internal_default_instance();

  void UnsafeArenaSwap(GraphOptions* other);
  void Swap(GraphOptions* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GraphOptions* other);
  void UnsafeMergeFrom(const GraphOptions& from);
  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;

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

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

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

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

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

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

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

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::OptimizerOptions* optimizer_options_;
  ::google::protobuf::int64 build_cost_model_;
  ::google::protobuf::int64 build_cost_model_after_;
  bool enable_recv_scheduling_;
  bool infer_shapes_;
  bool place_pruned_graph_;
  bool enable_bfloat16_sendrecv_;
  ::google::protobuf::int32 timeline_step_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<GraphOptions> GraphOptions_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ThreadPoolOptionProto& default_instance();

  static const ThreadPoolOptionProto* internal_default_instance();

  void UnsafeArenaSwap(ThreadPoolOptionProto* other);
  void Swap(ThreadPoolOptionProto* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ThreadPoolOptionProto* other);
  void UnsafeMergeFrom(const ThreadPoolOptionProto& from);
  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;

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

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

  // optional 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_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::int32 num_threads_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<ThreadPoolOptionProto> ThreadPoolOptionProto_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RPCOptions& default_instance();

  static const RPCOptions* internal_default_instance();

  void UnsafeArenaSwap(RPCOptions* other);
  void Swap(RPCOptions* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RPCOptions* other);
  void UnsafeMergeFrom(const RPCOptions& from);
  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;

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

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

  // optional 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_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool use_rpc_for_inprocess_master_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<RPCOptions> RPCOptions_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ConfigProto& default_instance();

  static const ConfigProto* internal_default_instance();

  void UnsafeArenaSwap(ConfigProto* other);
  void Swap(ConfigProto* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConfigProto* other);
  void UnsafeMergeFrom(const ConfigProto& from);
  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;

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  typedef ::google::protobuf::internal::MapEntryLite<
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 >
      ConfigProto_DeviceCountEntry;
  ::google::protobuf::internal::MapField<
      ::std::string, ::google::protobuf::int32,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_INT32,
      0 > device_count_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::ThreadPoolOptionProto > session_inter_op_thread_pool_;
  ::google::protobuf::RepeatedPtrField< ::std::string> device_filters_;
  ::tensorflow::GPUOptions* gpu_options_;
  ::tensorflow::GraphOptions* graph_options_;
  ::tensorflow::RPCOptions* rpc_options_;
  ::google::protobuf::int32 intra_op_parallelism_threads_;
  ::google::protobuf::int32 inter_op_parallelism_threads_;
  ::google::protobuf::int32 placement_period_;
  bool use_per_session_threads_;
  bool allow_soft_placement_;
  bool log_device_placement_;
  ::google::protobuf::int64 operation_timeout_in_ms_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<ConfigProto> ConfigProto_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunOptions& default_instance();

  static const RunOptions* internal_default_instance();

  void UnsafeArenaSwap(RunOptions* other);
  void Swap(RunOptions* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RunOptions* other);
  void UnsafeMergeFrom(const RunOptions& from);
  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;

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

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

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

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

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

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::DebugOptions* debug_options_;
  ::google::protobuf::int64 timeout_in_ms_;
  int trace_level_;
  ::google::protobuf::int32 inter_op_thread_pool_;
  bool output_partition_graphs_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<RunOptions> RunOptions_default_instance_;

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

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;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RunMetadata& default_instance();

  static const RunMetadata* internal_default_instance();

  void UnsafeArenaSwap(RunMetadata* other);
  void Swap(RunMetadata* other);

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

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

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

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RunMetadata* other);
  void UnsafeMergeFrom(const RunMetadata& from);
  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;

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

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

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::GraphDef > partition_graphs_;
  ::tensorflow::StepStats* step_stats_;
  ::tensorflow::CostGraphDef* cost_graph_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<RunMetadata> RunMetadata_default_instance_;

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


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// GPUOptions

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

// optional 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(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
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)
}
inline void GPUOptions::set_allocator_type(const char* value) {
  
  allocator_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.GPUOptions.allocator_type)
}
inline void GPUOptions::set_allocator_type(const char* value,
    size_t size) {
  
  allocator_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUOptions.allocator_type)
}
inline ::std::string* GPUOptions::mutable_allocator_type() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.allocator_type)
  return allocator_type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::release_allocator_type() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUOptions.allocator_type)
  
  return allocator_type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::unsafe_arena_release_allocator_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUOptions.allocator_type)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return allocator_type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void GPUOptions::set_allocated_allocator_type(::std::string* allocator_type) {
  if (allocator_type != NULL) {
    
  } else {
    
  }
  allocator_type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), allocator_type,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUOptions.allocator_type)
}
inline void GPUOptions::unsafe_arena_set_allocated_allocator_type(
    ::std::string* allocator_type) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (allocator_type != NULL) {
    
  } else {
    
  }
  allocator_type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      allocator_type, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUOptions.allocator_type)
}

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

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

// optional 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(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
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)
}
inline void GPUOptions::set_visible_device_list(const char* value) {
  
  visible_device_list_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.GPUOptions.visible_device_list)
}
inline void GPUOptions::set_visible_device_list(const char* value,
    size_t size) {
  
  visible_device_list_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUOptions.visible_device_list)
}
inline ::std::string* GPUOptions::mutable_visible_device_list() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUOptions.visible_device_list)
  return visible_device_list_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::release_visible_device_list() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUOptions.visible_device_list)
  
  return visible_device_list_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* GPUOptions::unsafe_arena_release_visible_device_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUOptions.visible_device_list)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return visible_device_list_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void GPUOptions::set_allocated_visible_device_list(::std::string* visible_device_list) {
  if (visible_device_list != NULL) {
    
  } else {
    
  }
  visible_device_list_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), visible_device_list,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUOptions.visible_device_list)
}
inline void GPUOptions::unsafe_arena_set_allocated_visible_device_list(
    ::std::string* visible_device_list) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (visible_device_list != NULL) {
    
  } else {
    
  }
  visible_device_list_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      visible_device_list, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUOptions.visible_device_list)
}

inline const GPUOptions* GPUOptions::internal_default_instance() {
  return &GPUOptions_default_instance_.get();
}
// -------------------------------------------------------------------

// OptimizerOptions

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

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

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

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

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

inline const OptimizerOptions* OptimizerOptions::internal_default_instance() {
  return &OptimizerOptions_default_instance_.get();
}
// -------------------------------------------------------------------

// GraphOptions

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

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

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

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

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

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

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

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

inline const GraphOptions* GraphOptions::internal_default_instance() {
  return &GraphOptions_default_instance_.get();
}
// -------------------------------------------------------------------

// ThreadPoolOptionProto

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

inline const ThreadPoolOptionProto* ThreadPoolOptionProto::internal_default_instance() {
  return &ThreadPoolOptionProto_default_instance_.get();
}
// -------------------------------------------------------------------

// RPCOptions

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

inline const RPCOptions* RPCOptions::internal_default_instance() {
  return &RPCOptions_default_instance_.get();
}
// -------------------------------------------------------------------

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

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

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

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

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

// optional 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);
}
inline void ConfigProto::set_device_filters(int index, const char* value) {
  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)
}
inline void ConfigProto::add_device_filters(const char* value) {
  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_;
}

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

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

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

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

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

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

inline const ConfigProto* ConfigProto::internal_default_instance() {
  return &ConfigProto_default_instance_.get();
}
// -------------------------------------------------------------------

// RunOptions

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

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

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

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

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

inline const RunOptions* RunOptions::internal_default_instance() {
  return &RunOptions_default_instance_.get();
}
// -------------------------------------------------------------------

// RunMetadata

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

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

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

inline const RunMetadata* RunMetadata::internal_default_instance() {
  return &RunMetadata_default_instance_.get();
}
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

#ifndef SWIG
namespace google {
namespace protobuf {

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

}  // namespace protobuf
}  // namespace google
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_tensorflow_2fcore_2fprotobuf_2fconfig_2eproto__INCLUDED
