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

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/any.pb.h>
#include "tensorflow/core/profiler/protobuf/diagnostics.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
namespace tensorflow {
namespace profiler {
class BottleneckAnalysis;
struct BottleneckAnalysisDefaultTypeInternal;
extern BottleneckAnalysisDefaultTypeInternal _BottleneckAnalysis_default_instance_;
class GenericStepTimeBreakdown;
struct GenericStepTimeBreakdownDefaultTypeInternal;
extern GenericStepTimeBreakdownDefaultTypeInternal _GenericStepTimeBreakdown_default_instance_;
class InputOpDetails;
struct InputOpDetailsDefaultTypeInternal;
extern InputOpDetailsDefaultTypeInternal _InputOpDetails_default_instance_;
class InputPipelineAnalysisRecommendation;
struct InputPipelineAnalysisRecommendationDefaultTypeInternal;
extern InputPipelineAnalysisRecommendationDefaultTypeInternal _InputPipelineAnalysisRecommendation_default_instance_;
class InputPipelineAnalysisResult;
struct InputPipelineAnalysisResultDefaultTypeInternal;
extern InputPipelineAnalysisResultDefaultTypeInternal _InputPipelineAnalysisResult_default_instance_;
class InputTimeBreakdown;
struct InputTimeBreakdownDefaultTypeInternal;
extern InputTimeBreakdownDefaultTypeInternal _InputTimeBreakdown_default_instance_;
class PerGenericStepDetails;
struct PerGenericStepDetailsDefaultTypeInternal;
extern PerGenericStepDetailsDefaultTypeInternal _PerGenericStepDetails_default_instance_;
class StepSummary;
struct StepSummaryDefaultTypeInternal;
extern StepSummaryDefaultTypeInternal _StepSummary_default_instance_;
}  // namespace profiler
}  // namespace tensorflow
PROTOBUF_NAMESPACE_OPEN
template<> ::tensorflow::profiler::BottleneckAnalysis* Arena::CreateMaybeMessage<::tensorflow::profiler::BottleneckAnalysis>(Arena*);
template<> ::tensorflow::profiler::GenericStepTimeBreakdown* Arena::CreateMaybeMessage<::tensorflow::profiler::GenericStepTimeBreakdown>(Arena*);
template<> ::tensorflow::profiler::InputOpDetails* Arena::CreateMaybeMessage<::tensorflow::profiler::InputOpDetails>(Arena*);
template<> ::tensorflow::profiler::InputPipelineAnalysisRecommendation* Arena::CreateMaybeMessage<::tensorflow::profiler::InputPipelineAnalysisRecommendation>(Arena*);
template<> ::tensorflow::profiler::InputPipelineAnalysisResult* Arena::CreateMaybeMessage<::tensorflow::profiler::InputPipelineAnalysisResult>(Arena*);
template<> ::tensorflow::profiler::InputTimeBreakdown* Arena::CreateMaybeMessage<::tensorflow::profiler::InputTimeBreakdown>(Arena*);
template<> ::tensorflow::profiler::PerGenericStepDetails* Arena::CreateMaybeMessage<::tensorflow::profiler::PerGenericStepDetails>(Arena*);
template<> ::tensorflow::profiler::StepSummary* Arena::CreateMaybeMessage<::tensorflow::profiler::StepSummary>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace tensorflow {
namespace profiler {

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

class BottleneckAnalysis final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.BottleneckAnalysis) */ {
 public:
  inline BottleneckAnalysis() : BottleneckAnalysis(nullptr) {}
  ~BottleneckAnalysis() override;
  explicit constexpr BottleneckAnalysis(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BottleneckAnalysis& operator=(const BottleneckAnalysis& from) {
    CopyFrom(from);
    return *this;
  }
  inline BottleneckAnalysis& operator=(BottleneckAnalysis&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(BottleneckAnalysis& a, BottleneckAnalysis& b) {
    a.Swap(&b);
  }
  inline void Swap(BottleneckAnalysis* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BottleneckAnalysis* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BottleneckAnalysis* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BottleneckAnalysis>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BottleneckAnalysis& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const BottleneckAnalysis& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BottleneckAnalysis* other);

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

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

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

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

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

  enum : int {
    kInputClassificationFieldNumber = 1,
    kInputStatementFieldNumber = 2,
    kKernelLaunchClassificationFieldNumber = 3,
    kKernelLaunchStatementFieldNumber = 4,
    kAllOtherClassificationFieldNumber = 5,
    kAllOtherStatementFieldNumber = 6,
    kDeviceCollectivesClassificationFieldNumber = 11,
    kDeviceCollectivesStatementFieldNumber = 12,
    kInputPercentFieldNumber = 7,
    kOutputPercentFieldNumber = 8,
    kIdlePercentFieldNumber = 9,
    kComputePercentFieldNumber = 10,
  };
  // string input_classification = 1;
  void clear_input_classification();
  const std::string& input_classification() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_input_classification(ArgT0&& arg0, ArgT... args);
  std::string* mutable_input_classification();
  PROTOBUF_NODISCARD std::string* release_input_classification();
  void set_allocated_input_classification(std::string* input_classification);
  private:
  const std::string& _internal_input_classification() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_classification(const std::string& value);
  std::string* _internal_mutable_input_classification();
  public:

  // string input_statement = 2;
  void clear_input_statement();
  const std::string& input_statement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_input_statement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_input_statement();
  PROTOBUF_NODISCARD std::string* release_input_statement();
  void set_allocated_input_statement(std::string* input_statement);
  private:
  const std::string& _internal_input_statement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_statement(const std::string& value);
  std::string* _internal_mutable_input_statement();
  public:

  // string kernel_launch_classification = 3;
  void clear_kernel_launch_classification();
  const std::string& kernel_launch_classification() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_kernel_launch_classification(ArgT0&& arg0, ArgT... args);
  std::string* mutable_kernel_launch_classification();
  PROTOBUF_NODISCARD std::string* release_kernel_launch_classification();
  void set_allocated_kernel_launch_classification(std::string* kernel_launch_classification);
  private:
  const std::string& _internal_kernel_launch_classification() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kernel_launch_classification(const std::string& value);
  std::string* _internal_mutable_kernel_launch_classification();
  public:

  // string kernel_launch_statement = 4;
  void clear_kernel_launch_statement();
  const std::string& kernel_launch_statement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_kernel_launch_statement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_kernel_launch_statement();
  PROTOBUF_NODISCARD std::string* release_kernel_launch_statement();
  void set_allocated_kernel_launch_statement(std::string* kernel_launch_statement);
  private:
  const std::string& _internal_kernel_launch_statement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kernel_launch_statement(const std::string& value);
  std::string* _internal_mutable_kernel_launch_statement();
  public:

  // string all_other_classification = 5;
  void clear_all_other_classification();
  const std::string& all_other_classification() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_all_other_classification(ArgT0&& arg0, ArgT... args);
  std::string* mutable_all_other_classification();
  PROTOBUF_NODISCARD std::string* release_all_other_classification();
  void set_allocated_all_other_classification(std::string* all_other_classification);
  private:
  const std::string& _internal_all_other_classification() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_all_other_classification(const std::string& value);
  std::string* _internal_mutable_all_other_classification();
  public:

  // string all_other_statement = 6;
  void clear_all_other_statement();
  const std::string& all_other_statement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_all_other_statement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_all_other_statement();
  PROTOBUF_NODISCARD std::string* release_all_other_statement();
  void set_allocated_all_other_statement(std::string* all_other_statement);
  private:
  const std::string& _internal_all_other_statement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_all_other_statement(const std::string& value);
  std::string* _internal_mutable_all_other_statement();
  public:

  // string device_collectives_classification = 11;
  void clear_device_collectives_classification();
  const std::string& device_collectives_classification() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_collectives_classification(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_collectives_classification();
  PROTOBUF_NODISCARD std::string* release_device_collectives_classification();
  void set_allocated_device_collectives_classification(std::string* device_collectives_classification);
  private:
  const std::string& _internal_device_collectives_classification() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_collectives_classification(const std::string& value);
  std::string* _internal_mutable_device_collectives_classification();
  public:

  // string device_collectives_statement = 12;
  void clear_device_collectives_statement();
  const std::string& device_collectives_statement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_collectives_statement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_collectives_statement();
  PROTOBUF_NODISCARD std::string* release_device_collectives_statement();
  void set_allocated_device_collectives_statement(std::string* device_collectives_statement);
  private:
  const std::string& _internal_device_collectives_statement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_collectives_statement(const std::string& value);
  std::string* _internal_mutable_device_collectives_statement();
  public:

  // double input_percent = 7;
  void clear_input_percent();
  double input_percent() const;
  void set_input_percent(double value);
  private:
  double _internal_input_percent() const;
  void _internal_set_input_percent(double value);
  public:

  // double output_percent = 8;
  void clear_output_percent();
  double output_percent() const;
  void set_output_percent(double value);
  private:
  double _internal_output_percent() const;
  void _internal_set_output_percent(double value);
  public:

  // double idle_percent = 9;
  void clear_idle_percent();
  double idle_percent() const;
  void set_idle_percent(double value);
  private:
  double _internal_idle_percent() const;
  void _internal_set_idle_percent(double value);
  public:

  // double compute_percent = 10;
  void clear_compute_percent();
  double compute_percent() const;
  void set_compute_percent(double value);
  private:
  double _internal_compute_percent() const;
  void _internal_set_compute_percent(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.BottleneckAnalysis)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_classification_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_statement_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kernel_launch_classification_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kernel_launch_statement_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr all_other_classification_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr all_other_statement_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_collectives_classification_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_collectives_statement_;
  double input_percent_;
  double output_percent_;
  double idle_percent_;
  double compute_percent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class StepSummary final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.StepSummary) */ {
 public:
  inline StepSummary() : StepSummary(nullptr) {}
  ~StepSummary() override;
  explicit constexpr StepSummary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline StepSummary& operator=(const StepSummary& from) {
    CopyFrom(from);
    return *this;
  }
  inline StepSummary& operator=(StepSummary&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(StepSummary& a, StepSummary& b) {
    a.Swap(&b);
  }
  inline void Swap(StepSummary* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StepSummary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  StepSummary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StepSummary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StepSummary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const StepSummary& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StepSummary* other);

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

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

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

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

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

  enum : int {
    kAverageFieldNumber = 1,
    kStandardDeviationFieldNumber = 2,
    kMinimumFieldNumber = 3,
    kMaximumFieldNumber = 4,
  };
  // double average = 1;
  void clear_average();
  double average() const;
  void set_average(double value);
  private:
  double _internal_average() const;
  void _internal_set_average(double value);
  public:

  // double standard_deviation = 2;
  void clear_standard_deviation();
  double standard_deviation() const;
  void set_standard_deviation(double value);
  private:
  double _internal_standard_deviation() const;
  void _internal_set_standard_deviation(double value);
  public:

  // double minimum = 3;
  void clear_minimum();
  double minimum() const;
  void set_minimum(double value);
  private:
  double _internal_minimum() const;
  void _internal_set_minimum(double value);
  public:

  // double maximum = 4;
  void clear_maximum();
  double maximum() const;
  void set_maximum(double value);
  private:
  double _internal_maximum() const;
  void _internal_set_maximum(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.StepSummary)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double average_;
  double standard_deviation_;
  double minimum_;
  double maximum_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class PerGenericStepDetails final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.PerGenericStepDetails) */ {
 public:
  inline PerGenericStepDetails() : PerGenericStepDetails(nullptr) {}
  ~PerGenericStepDetails() override;
  explicit constexpr PerGenericStepDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PerGenericStepDetails& operator=(const PerGenericStepDetails& from) {
    CopyFrom(from);
    return *this;
  }
  inline PerGenericStepDetails& operator=(PerGenericStepDetails&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(PerGenericStepDetails& a, PerGenericStepDetails& b) {
    a.Swap(&b);
  }
  inline void Swap(PerGenericStepDetails* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PerGenericStepDetails* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PerGenericStepDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PerGenericStepDetails>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PerGenericStepDetails& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PerGenericStepDetails& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PerGenericStepDetails* other);

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

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

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

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

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

  enum : int {
    kStepNameFieldNumber = 14,
    kStepTimeMsFieldNumber = 2,
    kUnknownTimeMsFieldNumber = 3,
    kOutputMsFieldNumber = 5,
    kDeviceComputeMsFieldNumber = 6,
    kDeviceToDeviceMsFieldNumber = 7,
    kHostComputeMsFieldNumber = 8,
    kHostPrepareMsFieldNumber = 9,
    kHostCompileMsFieldNumber = 10,
    kHostWaitInputMsFieldNumber = 11,
    kHostToDeviceMsFieldNumber = 12,
    kDeviceCollectivesMsFieldNumber = 13,
    kStepNumberFieldNumber = 1,
  };
  // string step_name = 14;
  void clear_step_name();
  const std::string& step_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_step_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_step_name();
  PROTOBUF_NODISCARD std::string* release_step_name();
  void set_allocated_step_name(std::string* step_name);
  private:
  const std::string& _internal_step_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_step_name(const std::string& value);
  std::string* _internal_mutable_step_name();
  public:

  // double step_time_ms = 2;
  void clear_step_time_ms();
  double step_time_ms() const;
  void set_step_time_ms(double value);
  private:
  double _internal_step_time_ms() const;
  void _internal_set_step_time_ms(double value);
  public:

  // double unknown_time_ms = 3;
  void clear_unknown_time_ms();
  double unknown_time_ms() const;
  void set_unknown_time_ms(double value);
  private:
  double _internal_unknown_time_ms() const;
  void _internal_set_unknown_time_ms(double value);
  public:

  // double output_ms = 5;
  void clear_output_ms();
  double output_ms() const;
  void set_output_ms(double value);
  private:
  double _internal_output_ms() const;
  void _internal_set_output_ms(double value);
  public:

  // double device_compute_ms = 6;
  void clear_device_compute_ms();
  double device_compute_ms() const;
  void set_device_compute_ms(double value);
  private:
  double _internal_device_compute_ms() const;
  void _internal_set_device_compute_ms(double value);
  public:

  // double device_to_device_ms = 7;
  void clear_device_to_device_ms();
  double device_to_device_ms() const;
  void set_device_to_device_ms(double value);
  private:
  double _internal_device_to_device_ms() const;
  void _internal_set_device_to_device_ms(double value);
  public:

  // double host_compute_ms = 8;
  void clear_host_compute_ms();
  double host_compute_ms() const;
  void set_host_compute_ms(double value);
  private:
  double _internal_host_compute_ms() const;
  void _internal_set_host_compute_ms(double value);
  public:

  // double host_prepare_ms = 9;
  void clear_host_prepare_ms();
  double host_prepare_ms() const;
  void set_host_prepare_ms(double value);
  private:
  double _internal_host_prepare_ms() const;
  void _internal_set_host_prepare_ms(double value);
  public:

  // double host_compile_ms = 10;
  void clear_host_compile_ms();
  double host_compile_ms() const;
  void set_host_compile_ms(double value);
  private:
  double _internal_host_compile_ms() const;
  void _internal_set_host_compile_ms(double value);
  public:

  // double host_wait_input_ms = 11;
  void clear_host_wait_input_ms();
  double host_wait_input_ms() const;
  void set_host_wait_input_ms(double value);
  private:
  double _internal_host_wait_input_ms() const;
  void _internal_set_host_wait_input_ms(double value);
  public:

  // double host_to_device_ms = 12;
  void clear_host_to_device_ms();
  double host_to_device_ms() const;
  void set_host_to_device_ms(double value);
  private:
  double _internal_host_to_device_ms() const;
  void _internal_set_host_to_device_ms(double value);
  public:

  // double device_collectives_ms = 13;
  void clear_device_collectives_ms();
  double device_collectives_ms() const;
  void set_device_collectives_ms(double value);
  private:
  double _internal_device_collectives_ms() const;
  void _internal_set_device_collectives_ms(double value);
  public:

  // int32 step_number = 1;
  void clear_step_number();
  int32_t step_number() const;
  void set_step_number(int32_t value);
  private:
  int32_t _internal_step_number() const;
  void _internal_set_step_number(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.PerGenericStepDetails)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr step_name_;
  double step_time_ms_;
  double unknown_time_ms_;
  double output_ms_;
  double device_compute_ms_;
  double device_to_device_ms_;
  double host_compute_ms_;
  double host_prepare_ms_;
  double host_compile_ms_;
  double host_wait_input_ms_;
  double host_to_device_ms_;
  double device_collectives_ms_;
  int32_t step_number_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class InputTimeBreakdown final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.InputTimeBreakdown) */ {
 public:
  inline InputTimeBreakdown() : InputTimeBreakdown(nullptr) {}
  ~InputTimeBreakdown() override;
  explicit constexpr InputTimeBreakdown(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InputTimeBreakdown& operator=(const InputTimeBreakdown& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputTimeBreakdown& operator=(InputTimeBreakdown&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(InputTimeBreakdown& a, InputTimeBreakdown& b) {
    a.Swap(&b);
  }
  inline void Swap(InputTimeBreakdown* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputTimeBreakdown* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputTimeBreakdown* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputTimeBreakdown>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputTimeBreakdown& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const InputTimeBreakdown& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputTimeBreakdown* other);

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

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

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

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

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

  enum : int {
    kDemandedFileReadUsFieldNumber = 1,
    kAdvancedFileReadUsFieldNumber = 2,
    kPreprocessingUsFieldNumber = 3,
    kEnqueueUsFieldNumber = 4,
    kUnclassifiedNonEnqueueUsFieldNumber = 5,
  };
  // double demanded_file_read_us = 1;
  void clear_demanded_file_read_us();
  double demanded_file_read_us() const;
  void set_demanded_file_read_us(double value);
  private:
  double _internal_demanded_file_read_us() const;
  void _internal_set_demanded_file_read_us(double value);
  public:

  // double advanced_file_read_us = 2;
  void clear_advanced_file_read_us();
  double advanced_file_read_us() const;
  void set_advanced_file_read_us(double value);
  private:
  double _internal_advanced_file_read_us() const;
  void _internal_set_advanced_file_read_us(double value);
  public:

  // double preprocessing_us = 3;
  void clear_preprocessing_us();
  double preprocessing_us() const;
  void set_preprocessing_us(double value);
  private:
  double _internal_preprocessing_us() const;
  void _internal_set_preprocessing_us(double value);
  public:

  // double enqueue_us = 4;
  void clear_enqueue_us();
  double enqueue_us() const;
  void set_enqueue_us(double value);
  private:
  double _internal_enqueue_us() const;
  void _internal_set_enqueue_us(double value);
  public:

  // double unclassified_non_enqueue_us = 5;
  void clear_unclassified_non_enqueue_us();
  double unclassified_non_enqueue_us() const;
  void set_unclassified_non_enqueue_us(double value);
  private:
  double _internal_unclassified_non_enqueue_us() const;
  void _internal_set_unclassified_non_enqueue_us(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.InputTimeBreakdown)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double demanded_file_read_us_;
  double advanced_file_read_us_;
  double preprocessing_us_;
  double enqueue_us_;
  double unclassified_non_enqueue_us_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class InputOpDetails final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.InputOpDetails) */ {
 public:
  inline InputOpDetails() : InputOpDetails(nullptr) {}
  ~InputOpDetails() override;
  explicit constexpr InputOpDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InputOpDetails& operator=(const InputOpDetails& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputOpDetails& operator=(InputOpDetails&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(InputOpDetails& a, InputOpDetails& b) {
    a.Swap(&b);
  }
  inline void Swap(InputOpDetails* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputOpDetails* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputOpDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputOpDetails>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputOpDetails& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const InputOpDetails& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputOpDetails* other);

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

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

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

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

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

  enum : int {
    kOpNameFieldNumber = 1,
    kCategoryFieldNumber = 7,
    kCountFieldNumber = 2,
    kTimeInMsFieldNumber = 3,
    kTimeInPercentFieldNumber = 4,
    kSelfTimeInMsFieldNumber = 5,
    kSelfTimeInPercentFieldNumber = 6,
  };
  // string op_name = 1;
  void clear_op_name();
  const std::string& op_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_op_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_op_name();
  PROTOBUF_NODISCARD std::string* release_op_name();
  void set_allocated_op_name(std::string* op_name);
  private:
  const std::string& _internal_op_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_name(const std::string& value);
  std::string* _internal_mutable_op_name();
  public:

  // string category = 7;
  void clear_category();
  const std::string& category() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_category(ArgT0&& arg0, ArgT... args);
  std::string* mutable_category();
  PROTOBUF_NODISCARD std::string* release_category();
  void set_allocated_category(std::string* category);
  private:
  const std::string& _internal_category() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_category(const std::string& value);
  std::string* _internal_mutable_category();
  public:

  // uint64 count = 2;
  void clear_count();
  uint64_t count() const;
  void set_count(uint64_t value);
  private:
  uint64_t _internal_count() const;
  void _internal_set_count(uint64_t value);
  public:

  // double time_in_ms = 3;
  void clear_time_in_ms();
  double time_in_ms() const;
  void set_time_in_ms(double value);
  private:
  double _internal_time_in_ms() const;
  void _internal_set_time_in_ms(double value);
  public:

  // double time_in_percent = 4;
  void clear_time_in_percent();
  double time_in_percent() const;
  void set_time_in_percent(double value);
  private:
  double _internal_time_in_percent() const;
  void _internal_set_time_in_percent(double value);
  public:

  // double self_time_in_ms = 5;
  void clear_self_time_in_ms();
  double self_time_in_ms() const;
  void set_self_time_in_ms(double value);
  private:
  double _internal_self_time_in_ms() const;
  void _internal_set_self_time_in_ms(double value);
  public:

  // double self_time_in_percent = 6;
  void clear_self_time_in_percent();
  double self_time_in_percent() const;
  void set_self_time_in_percent(double value);
  private:
  double _internal_self_time_in_percent() const;
  void _internal_set_self_time_in_percent(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.InputOpDetails)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr category_;
  uint64_t count_;
  double time_in_ms_;
  double time_in_percent_;
  double self_time_in_ms_;
  double self_time_in_percent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class InputPipelineAnalysisRecommendation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.InputPipelineAnalysisRecommendation) */ {
 public:
  inline InputPipelineAnalysisRecommendation() : InputPipelineAnalysisRecommendation(nullptr) {}
  ~InputPipelineAnalysisRecommendation() override;
  explicit constexpr InputPipelineAnalysisRecommendation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InputPipelineAnalysisRecommendation& operator=(const InputPipelineAnalysisRecommendation& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputPipelineAnalysisRecommendation& operator=(InputPipelineAnalysisRecommendation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(InputPipelineAnalysisRecommendation& a, InputPipelineAnalysisRecommendation& b) {
    a.Swap(&b);
  }
  inline void Swap(InputPipelineAnalysisRecommendation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputPipelineAnalysisRecommendation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputPipelineAnalysisRecommendation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputPipelineAnalysisRecommendation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputPipelineAnalysisRecommendation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const InputPipelineAnalysisRecommendation& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputPipelineAnalysisRecommendation* other);

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

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

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

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

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

  enum : int {
    kDetailsFieldNumber = 1,
    kSummaryNextStepFieldNumber = 3,
    kBottleneckAnalysisFieldNumber = 2,
  };
  // repeated string details = 1;
  int details_size() const;
  private:
  int _internal_details_size() const;
  public:
  void clear_details();
  const std::string& details(int index) const;
  std::string* mutable_details(int index);
  void set_details(int index, const std::string& value);
  void set_details(int index, std::string&& value);
  void set_details(int index, const char* value);
  void set_details(int index, const char* value, size_t size);
  std::string* add_details();
  void add_details(const std::string& value);
  void add_details(std::string&& value);
  void add_details(const char* value);
  void add_details(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& details() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_details();
  private:
  const std::string& _internal_details(int index) const;
  std::string* _internal_add_details();
  public:

  // string summary_next_step = 3;
  void clear_summary_next_step();
  const std::string& summary_next_step() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_summary_next_step(ArgT0&& arg0, ArgT... args);
  std::string* mutable_summary_next_step();
  PROTOBUF_NODISCARD std::string* release_summary_next_step();
  void set_allocated_summary_next_step(std::string* summary_next_step);
  private:
  const std::string& _internal_summary_next_step() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_summary_next_step(const std::string& value);
  std::string* _internal_mutable_summary_next_step();
  public:

  // .google.protobuf.Any bottleneck_analysis = 2;
  bool has_bottleneck_analysis() const;
  private:
  bool _internal_has_bottleneck_analysis() const;
  public:
  void clear_bottleneck_analysis();
  const ::PROTOBUF_NAMESPACE_ID::Any& bottleneck_analysis() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_bottleneck_analysis();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_bottleneck_analysis();
  void set_allocated_bottleneck_analysis(::PROTOBUF_NAMESPACE_ID::Any* bottleneck_analysis);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_bottleneck_analysis() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_bottleneck_analysis();
  public:
  void unsafe_arena_set_allocated_bottleneck_analysis(
      ::PROTOBUF_NAMESPACE_ID::Any* bottleneck_analysis);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_bottleneck_analysis();

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.InputPipelineAnalysisRecommendation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> details_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr summary_next_step_;
  ::PROTOBUF_NAMESPACE_ID::Any* bottleneck_analysis_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class GenericStepTimeBreakdown final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.GenericStepTimeBreakdown) */ {
 public:
  inline GenericStepTimeBreakdown() : GenericStepTimeBreakdown(nullptr) {}
  ~GenericStepTimeBreakdown() override;
  explicit constexpr GenericStepTimeBreakdown(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GenericStepTimeBreakdown& operator=(const GenericStepTimeBreakdown& from) {
    CopyFrom(from);
    return *this;
  }
  inline GenericStepTimeBreakdown& operator=(GenericStepTimeBreakdown&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(GenericStepTimeBreakdown& a, GenericStepTimeBreakdown& b) {
    a.Swap(&b);
  }
  inline void Swap(GenericStepTimeBreakdown* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GenericStepTimeBreakdown* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GenericStepTimeBreakdown* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GenericStepTimeBreakdown>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GenericStepTimeBreakdown& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const GenericStepTimeBreakdown& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GenericStepTimeBreakdown* other);

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

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

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

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

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

  enum : int {
    kUnknownTimeMsSummaryFieldNumber = 1,
    kOutputMsSummaryFieldNumber = 3,
    kDeviceComputeMsSummaryFieldNumber = 4,
    kDeviceToDeviceMsSummaryFieldNumber = 5,
    kHostComputeMsSummaryFieldNumber = 6,
    kHostPrepareMsSummaryFieldNumber = 7,
    kHostCompileMsSummaryFieldNumber = 8,
    kHostWaitInputMsSummaryFieldNumber = 9,
    kHostToDeviceMsSummaryFieldNumber = 10,
    kInputMsSummaryFieldNumber = 11,
    kDeviceCollectivesMsSummaryFieldNumber = 12,
  };
  // .tensorflow.profiler.StepSummary unknown_time_ms_summary = 1;
  bool has_unknown_time_ms_summary() const;
  private:
  bool _internal_has_unknown_time_ms_summary() const;
  public:
  void clear_unknown_time_ms_summary();
  const ::tensorflow::profiler::StepSummary& unknown_time_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_unknown_time_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_unknown_time_ms_summary();
  void set_allocated_unknown_time_ms_summary(::tensorflow::profiler::StepSummary* unknown_time_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_unknown_time_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_unknown_time_ms_summary();
  public:
  void unsafe_arena_set_allocated_unknown_time_ms_summary(
      ::tensorflow::profiler::StepSummary* unknown_time_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_unknown_time_ms_summary();

  // .tensorflow.profiler.StepSummary output_ms_summary = 3;
  bool has_output_ms_summary() const;
  private:
  bool _internal_has_output_ms_summary() const;
  public:
  void clear_output_ms_summary();
  const ::tensorflow::profiler::StepSummary& output_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_output_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_output_ms_summary();
  void set_allocated_output_ms_summary(::tensorflow::profiler::StepSummary* output_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_output_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_output_ms_summary();
  public:
  void unsafe_arena_set_allocated_output_ms_summary(
      ::tensorflow::profiler::StepSummary* output_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_output_ms_summary();

  // .tensorflow.profiler.StepSummary device_compute_ms_summary = 4;
  bool has_device_compute_ms_summary() const;
  private:
  bool _internal_has_device_compute_ms_summary() const;
  public:
  void clear_device_compute_ms_summary();
  const ::tensorflow::profiler::StepSummary& device_compute_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_device_compute_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_device_compute_ms_summary();
  void set_allocated_device_compute_ms_summary(::tensorflow::profiler::StepSummary* device_compute_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_device_compute_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_device_compute_ms_summary();
  public:
  void unsafe_arena_set_allocated_device_compute_ms_summary(
      ::tensorflow::profiler::StepSummary* device_compute_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_device_compute_ms_summary();

  // .tensorflow.profiler.StepSummary device_to_device_ms_summary = 5;
  bool has_device_to_device_ms_summary() const;
  private:
  bool _internal_has_device_to_device_ms_summary() const;
  public:
  void clear_device_to_device_ms_summary();
  const ::tensorflow::profiler::StepSummary& device_to_device_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_device_to_device_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_device_to_device_ms_summary();
  void set_allocated_device_to_device_ms_summary(::tensorflow::profiler::StepSummary* device_to_device_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_device_to_device_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_device_to_device_ms_summary();
  public:
  void unsafe_arena_set_allocated_device_to_device_ms_summary(
      ::tensorflow::profiler::StepSummary* device_to_device_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_device_to_device_ms_summary();

  // .tensorflow.profiler.StepSummary host_compute_ms_summary = 6;
  bool has_host_compute_ms_summary() const;
  private:
  bool _internal_has_host_compute_ms_summary() const;
  public:
  void clear_host_compute_ms_summary();
  const ::tensorflow::profiler::StepSummary& host_compute_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_host_compute_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_host_compute_ms_summary();
  void set_allocated_host_compute_ms_summary(::tensorflow::profiler::StepSummary* host_compute_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_host_compute_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_host_compute_ms_summary();
  public:
  void unsafe_arena_set_allocated_host_compute_ms_summary(
      ::tensorflow::profiler::StepSummary* host_compute_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_host_compute_ms_summary();

  // .tensorflow.profiler.StepSummary host_prepare_ms_summary = 7;
  bool has_host_prepare_ms_summary() const;
  private:
  bool _internal_has_host_prepare_ms_summary() const;
  public:
  void clear_host_prepare_ms_summary();
  const ::tensorflow::profiler::StepSummary& host_prepare_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_host_prepare_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_host_prepare_ms_summary();
  void set_allocated_host_prepare_ms_summary(::tensorflow::profiler::StepSummary* host_prepare_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_host_prepare_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_host_prepare_ms_summary();
  public:
  void unsafe_arena_set_allocated_host_prepare_ms_summary(
      ::tensorflow::profiler::StepSummary* host_prepare_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_host_prepare_ms_summary();

  // .tensorflow.profiler.StepSummary host_compile_ms_summary = 8;
  bool has_host_compile_ms_summary() const;
  private:
  bool _internal_has_host_compile_ms_summary() const;
  public:
  void clear_host_compile_ms_summary();
  const ::tensorflow::profiler::StepSummary& host_compile_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_host_compile_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_host_compile_ms_summary();
  void set_allocated_host_compile_ms_summary(::tensorflow::profiler::StepSummary* host_compile_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_host_compile_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_host_compile_ms_summary();
  public:
  void unsafe_arena_set_allocated_host_compile_ms_summary(
      ::tensorflow::profiler::StepSummary* host_compile_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_host_compile_ms_summary();

  // .tensorflow.profiler.StepSummary host_wait_input_ms_summary = 9;
  bool has_host_wait_input_ms_summary() const;
  private:
  bool _internal_has_host_wait_input_ms_summary() const;
  public:
  void clear_host_wait_input_ms_summary();
  const ::tensorflow::profiler::StepSummary& host_wait_input_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_host_wait_input_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_host_wait_input_ms_summary();
  void set_allocated_host_wait_input_ms_summary(::tensorflow::profiler::StepSummary* host_wait_input_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_host_wait_input_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_host_wait_input_ms_summary();
  public:
  void unsafe_arena_set_allocated_host_wait_input_ms_summary(
      ::tensorflow::profiler::StepSummary* host_wait_input_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_host_wait_input_ms_summary();

  // .tensorflow.profiler.StepSummary host_to_device_ms_summary = 10;
  bool has_host_to_device_ms_summary() const;
  private:
  bool _internal_has_host_to_device_ms_summary() const;
  public:
  void clear_host_to_device_ms_summary();
  const ::tensorflow::profiler::StepSummary& host_to_device_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_host_to_device_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_host_to_device_ms_summary();
  void set_allocated_host_to_device_ms_summary(::tensorflow::profiler::StepSummary* host_to_device_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_host_to_device_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_host_to_device_ms_summary();
  public:
  void unsafe_arena_set_allocated_host_to_device_ms_summary(
      ::tensorflow::profiler::StepSummary* host_to_device_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_host_to_device_ms_summary();

  // .tensorflow.profiler.StepSummary input_ms_summary = 11;
  bool has_input_ms_summary() const;
  private:
  bool _internal_has_input_ms_summary() const;
  public:
  void clear_input_ms_summary();
  const ::tensorflow::profiler::StepSummary& input_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_input_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_input_ms_summary();
  void set_allocated_input_ms_summary(::tensorflow::profiler::StepSummary* input_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_input_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_input_ms_summary();
  public:
  void unsafe_arena_set_allocated_input_ms_summary(
      ::tensorflow::profiler::StepSummary* input_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_input_ms_summary();

  // .tensorflow.profiler.StepSummary device_collectives_ms_summary = 12;
  bool has_device_collectives_ms_summary() const;
  private:
  bool _internal_has_device_collectives_ms_summary() const;
  public:
  void clear_device_collectives_ms_summary();
  const ::tensorflow::profiler::StepSummary& device_collectives_ms_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_device_collectives_ms_summary();
  ::tensorflow::profiler::StepSummary* mutable_device_collectives_ms_summary();
  void set_allocated_device_collectives_ms_summary(::tensorflow::profiler::StepSummary* device_collectives_ms_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_device_collectives_ms_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_device_collectives_ms_summary();
  public:
  void unsafe_arena_set_allocated_device_collectives_ms_summary(
      ::tensorflow::profiler::StepSummary* device_collectives_ms_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_device_collectives_ms_summary();

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.GenericStepTimeBreakdown)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::profiler::StepSummary* unknown_time_ms_summary_;
  ::tensorflow::profiler::StepSummary* output_ms_summary_;
  ::tensorflow::profiler::StepSummary* device_compute_ms_summary_;
  ::tensorflow::profiler::StepSummary* device_to_device_ms_summary_;
  ::tensorflow::profiler::StepSummary* host_compute_ms_summary_;
  ::tensorflow::profiler::StepSummary* host_prepare_ms_summary_;
  ::tensorflow::profiler::StepSummary* host_compile_ms_summary_;
  ::tensorflow::profiler::StepSummary* host_wait_input_ms_summary_;
  ::tensorflow::profiler::StepSummary* host_to_device_ms_summary_;
  ::tensorflow::profiler::StepSummary* input_ms_summary_;
  ::tensorflow::profiler::StepSummary* device_collectives_ms_summary_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// -------------------------------------------------------------------

class InputPipelineAnalysisResult final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.profiler.InputPipelineAnalysisResult) */ {
 public:
  inline InputPipelineAnalysisResult() : InputPipelineAnalysisResult(nullptr) {}
  ~InputPipelineAnalysisResult() override;
  explicit constexpr InputPipelineAnalysisResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InputPipelineAnalysisResult& operator=(const InputPipelineAnalysisResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputPipelineAnalysisResult& operator=(InputPipelineAnalysisResult&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(InputPipelineAnalysisResult& a, InputPipelineAnalysisResult& b) {
    a.Swap(&b);
  }
  inline void Swap(InputPipelineAnalysisResult* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputPipelineAnalysisResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputPipelineAnalysisResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputPipelineAnalysisResult>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputPipelineAnalysisResult& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const InputPipelineAnalysisResult& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputPipelineAnalysisResult* other);

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

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

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

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

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

  enum : int {
    kStepDetailsFieldNumber = 4,
    kInputOpDetailsFieldNumber = 6,
    kHardwareTypeFieldNumber = 9,
    kStepTimeSummaryFieldNumber = 2,
    kInputPercentSummaryFieldNumber = 3,
    kInputTimeBreakdownFieldNumber = 5,
    kRecommendationFieldNumber = 7,
    kStepTimeBreakdownFieldNumber = 8,
    kDiagnosticsFieldNumber = 12,
    kInputPercentFieldNumber = 11,
    kOutputPercentFieldNumber = 13,
    kIdlePercentFieldNumber = 14,
    kComputePercentFieldNumber = 15,
  };
  // repeated .google.protobuf.Any step_details = 4;
  int step_details_size() const;
  private:
  int _internal_step_details_size() const;
  public:
  void clear_step_details();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_step_details(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >*
      mutable_step_details();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_step_details(int index) const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_add_step_details();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Any& step_details(int index) const;
  ::PROTOBUF_NAMESPACE_ID::Any* add_step_details();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >&
      step_details() const;

  // repeated .tensorflow.profiler.InputOpDetails input_op_details = 6;
  int input_op_details_size() const;
  private:
  int _internal_input_op_details_size() const;
  public:
  void clear_input_op_details();
  ::tensorflow::profiler::InputOpDetails* mutable_input_op_details(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::profiler::InputOpDetails >*
      mutable_input_op_details();
  private:
  const ::tensorflow::profiler::InputOpDetails& _internal_input_op_details(int index) const;
  ::tensorflow::profiler::InputOpDetails* _internal_add_input_op_details();
  public:
  const ::tensorflow::profiler::InputOpDetails& input_op_details(int index) const;
  ::tensorflow::profiler::InputOpDetails* add_input_op_details();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::profiler::InputOpDetails >&
      input_op_details() const;

  // string hardware_type = 9;
  void clear_hardware_type();
  const std::string& hardware_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hardware_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hardware_type();
  PROTOBUF_NODISCARD std::string* release_hardware_type();
  void set_allocated_hardware_type(std::string* hardware_type);
  private:
  const std::string& _internal_hardware_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hardware_type(const std::string& value);
  std::string* _internal_mutable_hardware_type();
  public:

  // .tensorflow.profiler.StepSummary step_time_summary = 2;
  bool has_step_time_summary() const;
  private:
  bool _internal_has_step_time_summary() const;
  public:
  void clear_step_time_summary();
  const ::tensorflow::profiler::StepSummary& step_time_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_step_time_summary();
  ::tensorflow::profiler::StepSummary* mutable_step_time_summary();
  void set_allocated_step_time_summary(::tensorflow::profiler::StepSummary* step_time_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_step_time_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_step_time_summary();
  public:
  void unsafe_arena_set_allocated_step_time_summary(
      ::tensorflow::profiler::StepSummary* step_time_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_step_time_summary();

  // .tensorflow.profiler.StepSummary input_percent_summary = 3;
  bool has_input_percent_summary() const;
  private:
  bool _internal_has_input_percent_summary() const;
  public:
  void clear_input_percent_summary();
  const ::tensorflow::profiler::StepSummary& input_percent_summary() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::StepSummary* release_input_percent_summary();
  ::tensorflow::profiler::StepSummary* mutable_input_percent_summary();
  void set_allocated_input_percent_summary(::tensorflow::profiler::StepSummary* input_percent_summary);
  private:
  const ::tensorflow::profiler::StepSummary& _internal_input_percent_summary() const;
  ::tensorflow::profiler::StepSummary* _internal_mutable_input_percent_summary();
  public:
  void unsafe_arena_set_allocated_input_percent_summary(
      ::tensorflow::profiler::StepSummary* input_percent_summary);
  ::tensorflow::profiler::StepSummary* unsafe_arena_release_input_percent_summary();

  // .tensorflow.profiler.InputTimeBreakdown input_time_breakdown = 5;
  bool has_input_time_breakdown() const;
  private:
  bool _internal_has_input_time_breakdown() const;
  public:
  void clear_input_time_breakdown();
  const ::tensorflow::profiler::InputTimeBreakdown& input_time_breakdown() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::InputTimeBreakdown* release_input_time_breakdown();
  ::tensorflow::profiler::InputTimeBreakdown* mutable_input_time_breakdown();
  void set_allocated_input_time_breakdown(::tensorflow::profiler::InputTimeBreakdown* input_time_breakdown);
  private:
  const ::tensorflow::profiler::InputTimeBreakdown& _internal_input_time_breakdown() const;
  ::tensorflow::profiler::InputTimeBreakdown* _internal_mutable_input_time_breakdown();
  public:
  void unsafe_arena_set_allocated_input_time_breakdown(
      ::tensorflow::profiler::InputTimeBreakdown* input_time_breakdown);
  ::tensorflow::profiler::InputTimeBreakdown* unsafe_arena_release_input_time_breakdown();

  // .tensorflow.profiler.InputPipelineAnalysisRecommendation recommendation = 7;
  bool has_recommendation() const;
  private:
  bool _internal_has_recommendation() const;
  public:
  void clear_recommendation();
  const ::tensorflow::profiler::InputPipelineAnalysisRecommendation& recommendation() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::InputPipelineAnalysisRecommendation* release_recommendation();
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* mutable_recommendation();
  void set_allocated_recommendation(::tensorflow::profiler::InputPipelineAnalysisRecommendation* recommendation);
  private:
  const ::tensorflow::profiler::InputPipelineAnalysisRecommendation& _internal_recommendation() const;
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* _internal_mutable_recommendation();
  public:
  void unsafe_arena_set_allocated_recommendation(
      ::tensorflow::profiler::InputPipelineAnalysisRecommendation* recommendation);
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* unsafe_arena_release_recommendation();

  // .google.protobuf.Any step_time_breakdown = 8;
  bool has_step_time_breakdown() const;
  private:
  bool _internal_has_step_time_breakdown() const;
  public:
  void clear_step_time_breakdown();
  const ::PROTOBUF_NAMESPACE_ID::Any& step_time_breakdown() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_step_time_breakdown();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_step_time_breakdown();
  void set_allocated_step_time_breakdown(::PROTOBUF_NAMESPACE_ID::Any* step_time_breakdown);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_step_time_breakdown() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_step_time_breakdown();
  public:
  void unsafe_arena_set_allocated_step_time_breakdown(
      ::PROTOBUF_NAMESPACE_ID::Any* step_time_breakdown);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_step_time_breakdown();

  // .tensorflow.profiler.Diagnostics diagnostics = 12;
  bool has_diagnostics() const;
  private:
  bool _internal_has_diagnostics() const;
  public:
  void clear_diagnostics();
  const ::tensorflow::profiler::Diagnostics& diagnostics() const;
  PROTOBUF_NODISCARD ::tensorflow::profiler::Diagnostics* release_diagnostics();
  ::tensorflow::profiler::Diagnostics* mutable_diagnostics();
  void set_allocated_diagnostics(::tensorflow::profiler::Diagnostics* diagnostics);
  private:
  const ::tensorflow::profiler::Diagnostics& _internal_diagnostics() const;
  ::tensorflow::profiler::Diagnostics* _internal_mutable_diagnostics();
  public:
  void unsafe_arena_set_allocated_diagnostics(
      ::tensorflow::profiler::Diagnostics* diagnostics);
  ::tensorflow::profiler::Diagnostics* unsafe_arena_release_diagnostics();

  // double input_percent = 11;
  void clear_input_percent();
  double input_percent() const;
  void set_input_percent(double value);
  private:
  double _internal_input_percent() const;
  void _internal_set_input_percent(double value);
  public:

  // double output_percent = 13;
  void clear_output_percent();
  double output_percent() const;
  void set_output_percent(double value);
  private:
  double _internal_output_percent() const;
  void _internal_set_output_percent(double value);
  public:

  // double idle_percent = 14;
  void clear_idle_percent();
  double idle_percent() const;
  void set_idle_percent(double value);
  private:
  double _internal_idle_percent() const;
  void _internal_set_idle_percent(double value);
  public:

  // double compute_percent = 15;
  void clear_compute_percent();
  double compute_percent() const;
  void set_compute_percent(double value);
  private:
  double _internal_compute_percent() const;
  void _internal_set_compute_percent(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.profiler.InputPipelineAnalysisResult)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any > step_details_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::profiler::InputOpDetails > input_op_details_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hardware_type_;
  ::tensorflow::profiler::StepSummary* step_time_summary_;
  ::tensorflow::profiler::StepSummary* input_percent_summary_;
  ::tensorflow::profiler::InputTimeBreakdown* input_time_breakdown_;
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* recommendation_;
  ::PROTOBUF_NAMESPACE_ID::Any* step_time_breakdown_;
  ::tensorflow::profiler::Diagnostics* diagnostics_;
  double input_percent_;
  double output_percent_;
  double idle_percent_;
  double compute_percent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto;
};
// ===================================================================


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

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

// double input_percent = 7;
inline void BottleneckAnalysis::clear_input_percent() {
  input_percent_ = 0;
}
inline double BottleneckAnalysis::_internal_input_percent() const {
  return input_percent_;
}
inline double BottleneckAnalysis::input_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.input_percent)
  return _internal_input_percent();
}
inline void BottleneckAnalysis::_internal_set_input_percent(double value) {
  
  input_percent_ = value;
}
inline void BottleneckAnalysis::set_input_percent(double value) {
  _internal_set_input_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.input_percent)
}

// double output_percent = 8;
inline void BottleneckAnalysis::clear_output_percent() {
  output_percent_ = 0;
}
inline double BottleneckAnalysis::_internal_output_percent() const {
  return output_percent_;
}
inline double BottleneckAnalysis::output_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.output_percent)
  return _internal_output_percent();
}
inline void BottleneckAnalysis::_internal_set_output_percent(double value) {
  
  output_percent_ = value;
}
inline void BottleneckAnalysis::set_output_percent(double value) {
  _internal_set_output_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.output_percent)
}

// double idle_percent = 9;
inline void BottleneckAnalysis::clear_idle_percent() {
  idle_percent_ = 0;
}
inline double BottleneckAnalysis::_internal_idle_percent() const {
  return idle_percent_;
}
inline double BottleneckAnalysis::idle_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.idle_percent)
  return _internal_idle_percent();
}
inline void BottleneckAnalysis::_internal_set_idle_percent(double value) {
  
  idle_percent_ = value;
}
inline void BottleneckAnalysis::set_idle_percent(double value) {
  _internal_set_idle_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.idle_percent)
}

// double compute_percent = 10;
inline void BottleneckAnalysis::clear_compute_percent() {
  compute_percent_ = 0;
}
inline double BottleneckAnalysis::_internal_compute_percent() const {
  return compute_percent_;
}
inline double BottleneckAnalysis::compute_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.compute_percent)
  return _internal_compute_percent();
}
inline void BottleneckAnalysis::_internal_set_compute_percent(double value) {
  
  compute_percent_ = value;
}
inline void BottleneckAnalysis::set_compute_percent(double value) {
  _internal_set_compute_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.compute_percent)
}

// string input_classification = 1;
inline void BottleneckAnalysis::clear_input_classification() {
  input_classification_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::input_classification() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.input_classification)
  return _internal_input_classification();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_input_classification(ArgT0&& arg0, ArgT... args) {
 
 input_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.input_classification)
}
inline std::string* BottleneckAnalysis::mutable_input_classification() {
  std::string* _s = _internal_mutable_input_classification();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.input_classification)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_input_classification() const {
  return input_classification_.Get();
}
inline void BottleneckAnalysis::_internal_set_input_classification(const std::string& value) {
  
  input_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_input_classification() {
  
  return input_classification_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_input_classification() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.input_classification)
  return input_classification_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_input_classification(std::string* input_classification) {
  if (input_classification != nullptr) {
    
  } else {
    
  }
  input_classification_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), input_classification,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (input_classification_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    input_classification_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.input_classification)
}

// string input_statement = 2;
inline void BottleneckAnalysis::clear_input_statement() {
  input_statement_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::input_statement() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.input_statement)
  return _internal_input_statement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_input_statement(ArgT0&& arg0, ArgT... args) {
 
 input_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.input_statement)
}
inline std::string* BottleneckAnalysis::mutable_input_statement() {
  std::string* _s = _internal_mutable_input_statement();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.input_statement)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_input_statement() const {
  return input_statement_.Get();
}
inline void BottleneckAnalysis::_internal_set_input_statement(const std::string& value) {
  
  input_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_input_statement() {
  
  return input_statement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_input_statement() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.input_statement)
  return input_statement_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_input_statement(std::string* input_statement) {
  if (input_statement != nullptr) {
    
  } else {
    
  }
  input_statement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), input_statement,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (input_statement_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    input_statement_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.input_statement)
}

// string kernel_launch_classification = 3;
inline void BottleneckAnalysis::clear_kernel_launch_classification() {
  kernel_launch_classification_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::kernel_launch_classification() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.kernel_launch_classification)
  return _internal_kernel_launch_classification();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_kernel_launch_classification(ArgT0&& arg0, ArgT... args) {
 
 kernel_launch_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.kernel_launch_classification)
}
inline std::string* BottleneckAnalysis::mutable_kernel_launch_classification() {
  std::string* _s = _internal_mutable_kernel_launch_classification();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.kernel_launch_classification)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_kernel_launch_classification() const {
  return kernel_launch_classification_.Get();
}
inline void BottleneckAnalysis::_internal_set_kernel_launch_classification(const std::string& value) {
  
  kernel_launch_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_kernel_launch_classification() {
  
  return kernel_launch_classification_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_kernel_launch_classification() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.kernel_launch_classification)
  return kernel_launch_classification_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_kernel_launch_classification(std::string* kernel_launch_classification) {
  if (kernel_launch_classification != nullptr) {
    
  } else {
    
  }
  kernel_launch_classification_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), kernel_launch_classification,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (kernel_launch_classification_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    kernel_launch_classification_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.kernel_launch_classification)
}

// string kernel_launch_statement = 4;
inline void BottleneckAnalysis::clear_kernel_launch_statement() {
  kernel_launch_statement_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::kernel_launch_statement() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.kernel_launch_statement)
  return _internal_kernel_launch_statement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_kernel_launch_statement(ArgT0&& arg0, ArgT... args) {
 
 kernel_launch_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.kernel_launch_statement)
}
inline std::string* BottleneckAnalysis::mutable_kernel_launch_statement() {
  std::string* _s = _internal_mutable_kernel_launch_statement();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.kernel_launch_statement)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_kernel_launch_statement() const {
  return kernel_launch_statement_.Get();
}
inline void BottleneckAnalysis::_internal_set_kernel_launch_statement(const std::string& value) {
  
  kernel_launch_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_kernel_launch_statement() {
  
  return kernel_launch_statement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_kernel_launch_statement() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.kernel_launch_statement)
  return kernel_launch_statement_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_kernel_launch_statement(std::string* kernel_launch_statement) {
  if (kernel_launch_statement != nullptr) {
    
  } else {
    
  }
  kernel_launch_statement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), kernel_launch_statement,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (kernel_launch_statement_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    kernel_launch_statement_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.kernel_launch_statement)
}

// string all_other_classification = 5;
inline void BottleneckAnalysis::clear_all_other_classification() {
  all_other_classification_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::all_other_classification() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.all_other_classification)
  return _internal_all_other_classification();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_all_other_classification(ArgT0&& arg0, ArgT... args) {
 
 all_other_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.all_other_classification)
}
inline std::string* BottleneckAnalysis::mutable_all_other_classification() {
  std::string* _s = _internal_mutable_all_other_classification();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.all_other_classification)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_all_other_classification() const {
  return all_other_classification_.Get();
}
inline void BottleneckAnalysis::_internal_set_all_other_classification(const std::string& value) {
  
  all_other_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_all_other_classification() {
  
  return all_other_classification_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_all_other_classification() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.all_other_classification)
  return all_other_classification_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_all_other_classification(std::string* all_other_classification) {
  if (all_other_classification != nullptr) {
    
  } else {
    
  }
  all_other_classification_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), all_other_classification,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (all_other_classification_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    all_other_classification_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.all_other_classification)
}

// string all_other_statement = 6;
inline void BottleneckAnalysis::clear_all_other_statement() {
  all_other_statement_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::all_other_statement() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.all_other_statement)
  return _internal_all_other_statement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_all_other_statement(ArgT0&& arg0, ArgT... args) {
 
 all_other_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.all_other_statement)
}
inline std::string* BottleneckAnalysis::mutable_all_other_statement() {
  std::string* _s = _internal_mutable_all_other_statement();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.all_other_statement)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_all_other_statement() const {
  return all_other_statement_.Get();
}
inline void BottleneckAnalysis::_internal_set_all_other_statement(const std::string& value) {
  
  all_other_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_all_other_statement() {
  
  return all_other_statement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_all_other_statement() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.all_other_statement)
  return all_other_statement_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_all_other_statement(std::string* all_other_statement) {
  if (all_other_statement != nullptr) {
    
  } else {
    
  }
  all_other_statement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), all_other_statement,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (all_other_statement_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    all_other_statement_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.all_other_statement)
}

// string device_collectives_classification = 11;
inline void BottleneckAnalysis::clear_device_collectives_classification() {
  device_collectives_classification_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::device_collectives_classification() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.device_collectives_classification)
  return _internal_device_collectives_classification();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_device_collectives_classification(ArgT0&& arg0, ArgT... args) {
 
 device_collectives_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.device_collectives_classification)
}
inline std::string* BottleneckAnalysis::mutable_device_collectives_classification() {
  std::string* _s = _internal_mutable_device_collectives_classification();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.device_collectives_classification)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_device_collectives_classification() const {
  return device_collectives_classification_.Get();
}
inline void BottleneckAnalysis::_internal_set_device_collectives_classification(const std::string& value) {
  
  device_collectives_classification_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_device_collectives_classification() {
  
  return device_collectives_classification_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_device_collectives_classification() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.device_collectives_classification)
  return device_collectives_classification_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_device_collectives_classification(std::string* device_collectives_classification) {
  if (device_collectives_classification != nullptr) {
    
  } else {
    
  }
  device_collectives_classification_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_collectives_classification,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_collectives_classification_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_collectives_classification_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.device_collectives_classification)
}

// string device_collectives_statement = 12;
inline void BottleneckAnalysis::clear_device_collectives_statement() {
  device_collectives_statement_.ClearToEmpty();
}
inline const std::string& BottleneckAnalysis::device_collectives_statement() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.BottleneckAnalysis.device_collectives_statement)
  return _internal_device_collectives_statement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BottleneckAnalysis::set_device_collectives_statement(ArgT0&& arg0, ArgT... args) {
 
 device_collectives_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.BottleneckAnalysis.device_collectives_statement)
}
inline std::string* BottleneckAnalysis::mutable_device_collectives_statement() {
  std::string* _s = _internal_mutable_device_collectives_statement();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.BottleneckAnalysis.device_collectives_statement)
  return _s;
}
inline const std::string& BottleneckAnalysis::_internal_device_collectives_statement() const {
  return device_collectives_statement_.Get();
}
inline void BottleneckAnalysis::_internal_set_device_collectives_statement(const std::string& value) {
  
  device_collectives_statement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::_internal_mutable_device_collectives_statement() {
  
  return device_collectives_statement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* BottleneckAnalysis::release_device_collectives_statement() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.BottleneckAnalysis.device_collectives_statement)
  return device_collectives_statement_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void BottleneckAnalysis::set_allocated_device_collectives_statement(std::string* device_collectives_statement) {
  if (device_collectives_statement != nullptr) {
    
  } else {
    
  }
  device_collectives_statement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_collectives_statement,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_collectives_statement_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_collectives_statement_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.BottleneckAnalysis.device_collectives_statement)
}

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

// StepSummary

// double average = 1;
inline void StepSummary::clear_average() {
  average_ = 0;
}
inline double StepSummary::_internal_average() const {
  return average_;
}
inline double StepSummary::average() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.StepSummary.average)
  return _internal_average();
}
inline void StepSummary::_internal_set_average(double value) {
  
  average_ = value;
}
inline void StepSummary::set_average(double value) {
  _internal_set_average(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.StepSummary.average)
}

// double standard_deviation = 2;
inline void StepSummary::clear_standard_deviation() {
  standard_deviation_ = 0;
}
inline double StepSummary::_internal_standard_deviation() const {
  return standard_deviation_;
}
inline double StepSummary::standard_deviation() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.StepSummary.standard_deviation)
  return _internal_standard_deviation();
}
inline void StepSummary::_internal_set_standard_deviation(double value) {
  
  standard_deviation_ = value;
}
inline void StepSummary::set_standard_deviation(double value) {
  _internal_set_standard_deviation(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.StepSummary.standard_deviation)
}

// double minimum = 3;
inline void StepSummary::clear_minimum() {
  minimum_ = 0;
}
inline double StepSummary::_internal_minimum() const {
  return minimum_;
}
inline double StepSummary::minimum() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.StepSummary.minimum)
  return _internal_minimum();
}
inline void StepSummary::_internal_set_minimum(double value) {
  
  minimum_ = value;
}
inline void StepSummary::set_minimum(double value) {
  _internal_set_minimum(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.StepSummary.minimum)
}

// double maximum = 4;
inline void StepSummary::clear_maximum() {
  maximum_ = 0;
}
inline double StepSummary::_internal_maximum() const {
  return maximum_;
}
inline double StepSummary::maximum() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.StepSummary.maximum)
  return _internal_maximum();
}
inline void StepSummary::_internal_set_maximum(double value) {
  
  maximum_ = value;
}
inline void StepSummary::set_maximum(double value) {
  _internal_set_maximum(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.StepSummary.maximum)
}

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

// PerGenericStepDetails

// int32 step_number = 1;
inline void PerGenericStepDetails::clear_step_number() {
  step_number_ = 0;
}
inline int32_t PerGenericStepDetails::_internal_step_number() const {
  return step_number_;
}
inline int32_t PerGenericStepDetails::step_number() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.step_number)
  return _internal_step_number();
}
inline void PerGenericStepDetails::_internal_set_step_number(int32_t value) {
  
  step_number_ = value;
}
inline void PerGenericStepDetails::set_step_number(int32_t value) {
  _internal_set_step_number(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.step_number)
}

// string step_name = 14;
inline void PerGenericStepDetails::clear_step_name() {
  step_name_.ClearToEmpty();
}
inline const std::string& PerGenericStepDetails::step_name() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.step_name)
  return _internal_step_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerGenericStepDetails::set_step_name(ArgT0&& arg0, ArgT... args) {
 
 step_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.step_name)
}
inline std::string* PerGenericStepDetails::mutable_step_name() {
  std::string* _s = _internal_mutable_step_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.PerGenericStepDetails.step_name)
  return _s;
}
inline const std::string& PerGenericStepDetails::_internal_step_name() const {
  return step_name_.Get();
}
inline void PerGenericStepDetails::_internal_set_step_name(const std::string& value) {
  
  step_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PerGenericStepDetails::_internal_mutable_step_name() {
  
  return step_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PerGenericStepDetails::release_step_name() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.PerGenericStepDetails.step_name)
  return step_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void PerGenericStepDetails::set_allocated_step_name(std::string* step_name) {
  if (step_name != nullptr) {
    
  } else {
    
  }
  step_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), step_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (step_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    step_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.PerGenericStepDetails.step_name)
}

// double step_time_ms = 2;
inline void PerGenericStepDetails::clear_step_time_ms() {
  step_time_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_step_time_ms() const {
  return step_time_ms_;
}
inline double PerGenericStepDetails::step_time_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.step_time_ms)
  return _internal_step_time_ms();
}
inline void PerGenericStepDetails::_internal_set_step_time_ms(double value) {
  
  step_time_ms_ = value;
}
inline void PerGenericStepDetails::set_step_time_ms(double value) {
  _internal_set_step_time_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.step_time_ms)
}

// double unknown_time_ms = 3;
inline void PerGenericStepDetails::clear_unknown_time_ms() {
  unknown_time_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_unknown_time_ms() const {
  return unknown_time_ms_;
}
inline double PerGenericStepDetails::unknown_time_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.unknown_time_ms)
  return _internal_unknown_time_ms();
}
inline void PerGenericStepDetails::_internal_set_unknown_time_ms(double value) {
  
  unknown_time_ms_ = value;
}
inline void PerGenericStepDetails::set_unknown_time_ms(double value) {
  _internal_set_unknown_time_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.unknown_time_ms)
}

// double host_wait_input_ms = 11;
inline void PerGenericStepDetails::clear_host_wait_input_ms() {
  host_wait_input_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_host_wait_input_ms() const {
  return host_wait_input_ms_;
}
inline double PerGenericStepDetails::host_wait_input_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.host_wait_input_ms)
  return _internal_host_wait_input_ms();
}
inline void PerGenericStepDetails::_internal_set_host_wait_input_ms(double value) {
  
  host_wait_input_ms_ = value;
}
inline void PerGenericStepDetails::set_host_wait_input_ms(double value) {
  _internal_set_host_wait_input_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.host_wait_input_ms)
}

// double host_to_device_ms = 12;
inline void PerGenericStepDetails::clear_host_to_device_ms() {
  host_to_device_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_host_to_device_ms() const {
  return host_to_device_ms_;
}
inline double PerGenericStepDetails::host_to_device_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.host_to_device_ms)
  return _internal_host_to_device_ms();
}
inline void PerGenericStepDetails::_internal_set_host_to_device_ms(double value) {
  
  host_to_device_ms_ = value;
}
inline void PerGenericStepDetails::set_host_to_device_ms(double value) {
  _internal_set_host_to_device_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.host_to_device_ms)
}

// double output_ms = 5;
inline void PerGenericStepDetails::clear_output_ms() {
  output_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_output_ms() const {
  return output_ms_;
}
inline double PerGenericStepDetails::output_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.output_ms)
  return _internal_output_ms();
}
inline void PerGenericStepDetails::_internal_set_output_ms(double value) {
  
  output_ms_ = value;
}
inline void PerGenericStepDetails::set_output_ms(double value) {
  _internal_set_output_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.output_ms)
}

// double device_compute_ms = 6;
inline void PerGenericStepDetails::clear_device_compute_ms() {
  device_compute_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_device_compute_ms() const {
  return device_compute_ms_;
}
inline double PerGenericStepDetails::device_compute_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.device_compute_ms)
  return _internal_device_compute_ms();
}
inline void PerGenericStepDetails::_internal_set_device_compute_ms(double value) {
  
  device_compute_ms_ = value;
}
inline void PerGenericStepDetails::set_device_compute_ms(double value) {
  _internal_set_device_compute_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.device_compute_ms)
}

// double device_to_device_ms = 7;
inline void PerGenericStepDetails::clear_device_to_device_ms() {
  device_to_device_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_device_to_device_ms() const {
  return device_to_device_ms_;
}
inline double PerGenericStepDetails::device_to_device_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.device_to_device_ms)
  return _internal_device_to_device_ms();
}
inline void PerGenericStepDetails::_internal_set_device_to_device_ms(double value) {
  
  device_to_device_ms_ = value;
}
inline void PerGenericStepDetails::set_device_to_device_ms(double value) {
  _internal_set_device_to_device_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.device_to_device_ms)
}

// double device_collectives_ms = 13;
inline void PerGenericStepDetails::clear_device_collectives_ms() {
  device_collectives_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_device_collectives_ms() const {
  return device_collectives_ms_;
}
inline double PerGenericStepDetails::device_collectives_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.device_collectives_ms)
  return _internal_device_collectives_ms();
}
inline void PerGenericStepDetails::_internal_set_device_collectives_ms(double value) {
  
  device_collectives_ms_ = value;
}
inline void PerGenericStepDetails::set_device_collectives_ms(double value) {
  _internal_set_device_collectives_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.device_collectives_ms)
}

// double host_compute_ms = 8;
inline void PerGenericStepDetails::clear_host_compute_ms() {
  host_compute_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_host_compute_ms() const {
  return host_compute_ms_;
}
inline double PerGenericStepDetails::host_compute_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.host_compute_ms)
  return _internal_host_compute_ms();
}
inline void PerGenericStepDetails::_internal_set_host_compute_ms(double value) {
  
  host_compute_ms_ = value;
}
inline void PerGenericStepDetails::set_host_compute_ms(double value) {
  _internal_set_host_compute_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.host_compute_ms)
}

// double host_prepare_ms = 9;
inline void PerGenericStepDetails::clear_host_prepare_ms() {
  host_prepare_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_host_prepare_ms() const {
  return host_prepare_ms_;
}
inline double PerGenericStepDetails::host_prepare_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.host_prepare_ms)
  return _internal_host_prepare_ms();
}
inline void PerGenericStepDetails::_internal_set_host_prepare_ms(double value) {
  
  host_prepare_ms_ = value;
}
inline void PerGenericStepDetails::set_host_prepare_ms(double value) {
  _internal_set_host_prepare_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.host_prepare_ms)
}

// double host_compile_ms = 10;
inline void PerGenericStepDetails::clear_host_compile_ms() {
  host_compile_ms_ = 0;
}
inline double PerGenericStepDetails::_internal_host_compile_ms() const {
  return host_compile_ms_;
}
inline double PerGenericStepDetails::host_compile_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.PerGenericStepDetails.host_compile_ms)
  return _internal_host_compile_ms();
}
inline void PerGenericStepDetails::_internal_set_host_compile_ms(double value) {
  
  host_compile_ms_ = value;
}
inline void PerGenericStepDetails::set_host_compile_ms(double value) {
  _internal_set_host_compile_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.PerGenericStepDetails.host_compile_ms)
}

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

// InputTimeBreakdown

// double demanded_file_read_us = 1;
inline void InputTimeBreakdown::clear_demanded_file_read_us() {
  demanded_file_read_us_ = 0;
}
inline double InputTimeBreakdown::_internal_demanded_file_read_us() const {
  return demanded_file_read_us_;
}
inline double InputTimeBreakdown::demanded_file_read_us() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputTimeBreakdown.demanded_file_read_us)
  return _internal_demanded_file_read_us();
}
inline void InputTimeBreakdown::_internal_set_demanded_file_read_us(double value) {
  
  demanded_file_read_us_ = value;
}
inline void InputTimeBreakdown::set_demanded_file_read_us(double value) {
  _internal_set_demanded_file_read_us(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputTimeBreakdown.demanded_file_read_us)
}

// double advanced_file_read_us = 2;
inline void InputTimeBreakdown::clear_advanced_file_read_us() {
  advanced_file_read_us_ = 0;
}
inline double InputTimeBreakdown::_internal_advanced_file_read_us() const {
  return advanced_file_read_us_;
}
inline double InputTimeBreakdown::advanced_file_read_us() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputTimeBreakdown.advanced_file_read_us)
  return _internal_advanced_file_read_us();
}
inline void InputTimeBreakdown::_internal_set_advanced_file_read_us(double value) {
  
  advanced_file_read_us_ = value;
}
inline void InputTimeBreakdown::set_advanced_file_read_us(double value) {
  _internal_set_advanced_file_read_us(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputTimeBreakdown.advanced_file_read_us)
}

// double preprocessing_us = 3;
inline void InputTimeBreakdown::clear_preprocessing_us() {
  preprocessing_us_ = 0;
}
inline double InputTimeBreakdown::_internal_preprocessing_us() const {
  return preprocessing_us_;
}
inline double InputTimeBreakdown::preprocessing_us() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputTimeBreakdown.preprocessing_us)
  return _internal_preprocessing_us();
}
inline void InputTimeBreakdown::_internal_set_preprocessing_us(double value) {
  
  preprocessing_us_ = value;
}
inline void InputTimeBreakdown::set_preprocessing_us(double value) {
  _internal_set_preprocessing_us(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputTimeBreakdown.preprocessing_us)
}

// double enqueue_us = 4;
inline void InputTimeBreakdown::clear_enqueue_us() {
  enqueue_us_ = 0;
}
inline double InputTimeBreakdown::_internal_enqueue_us() const {
  return enqueue_us_;
}
inline double InputTimeBreakdown::enqueue_us() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputTimeBreakdown.enqueue_us)
  return _internal_enqueue_us();
}
inline void InputTimeBreakdown::_internal_set_enqueue_us(double value) {
  
  enqueue_us_ = value;
}
inline void InputTimeBreakdown::set_enqueue_us(double value) {
  _internal_set_enqueue_us(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputTimeBreakdown.enqueue_us)
}

// double unclassified_non_enqueue_us = 5;
inline void InputTimeBreakdown::clear_unclassified_non_enqueue_us() {
  unclassified_non_enqueue_us_ = 0;
}
inline double InputTimeBreakdown::_internal_unclassified_non_enqueue_us() const {
  return unclassified_non_enqueue_us_;
}
inline double InputTimeBreakdown::unclassified_non_enqueue_us() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputTimeBreakdown.unclassified_non_enqueue_us)
  return _internal_unclassified_non_enqueue_us();
}
inline void InputTimeBreakdown::_internal_set_unclassified_non_enqueue_us(double value) {
  
  unclassified_non_enqueue_us_ = value;
}
inline void InputTimeBreakdown::set_unclassified_non_enqueue_us(double value) {
  _internal_set_unclassified_non_enqueue_us(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputTimeBreakdown.unclassified_non_enqueue_us)
}

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

// InputOpDetails

// string op_name = 1;
inline void InputOpDetails::clear_op_name() {
  op_name_.ClearToEmpty();
}
inline const std::string& InputOpDetails::op_name() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.op_name)
  return _internal_op_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputOpDetails::set_op_name(ArgT0&& arg0, ArgT... args) {
 
 op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.op_name)
}
inline std::string* InputOpDetails::mutable_op_name() {
  std::string* _s = _internal_mutable_op_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputOpDetails.op_name)
  return _s;
}
inline const std::string& InputOpDetails::_internal_op_name() const {
  return op_name_.Get();
}
inline void InputOpDetails::_internal_set_op_name(const std::string& value) {
  
  op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* InputOpDetails::_internal_mutable_op_name() {
  
  return op_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* InputOpDetails::release_op_name() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputOpDetails.op_name)
  return op_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void InputOpDetails::set_allocated_op_name(std::string* op_name) {
  if (op_name != nullptr) {
    
  } else {
    
  }
  op_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (op_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputOpDetails.op_name)
}

// uint64 count = 2;
inline void InputOpDetails::clear_count() {
  count_ = uint64_t{0u};
}
inline uint64_t InputOpDetails::_internal_count() const {
  return count_;
}
inline uint64_t InputOpDetails::count() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.count)
  return _internal_count();
}
inline void InputOpDetails::_internal_set_count(uint64_t value) {
  
  count_ = value;
}
inline void InputOpDetails::set_count(uint64_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.count)
}

// double time_in_ms = 3;
inline void InputOpDetails::clear_time_in_ms() {
  time_in_ms_ = 0;
}
inline double InputOpDetails::_internal_time_in_ms() const {
  return time_in_ms_;
}
inline double InputOpDetails::time_in_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.time_in_ms)
  return _internal_time_in_ms();
}
inline void InputOpDetails::_internal_set_time_in_ms(double value) {
  
  time_in_ms_ = value;
}
inline void InputOpDetails::set_time_in_ms(double value) {
  _internal_set_time_in_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.time_in_ms)
}

// double time_in_percent = 4;
inline void InputOpDetails::clear_time_in_percent() {
  time_in_percent_ = 0;
}
inline double InputOpDetails::_internal_time_in_percent() const {
  return time_in_percent_;
}
inline double InputOpDetails::time_in_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.time_in_percent)
  return _internal_time_in_percent();
}
inline void InputOpDetails::_internal_set_time_in_percent(double value) {
  
  time_in_percent_ = value;
}
inline void InputOpDetails::set_time_in_percent(double value) {
  _internal_set_time_in_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.time_in_percent)
}

// double self_time_in_ms = 5;
inline void InputOpDetails::clear_self_time_in_ms() {
  self_time_in_ms_ = 0;
}
inline double InputOpDetails::_internal_self_time_in_ms() const {
  return self_time_in_ms_;
}
inline double InputOpDetails::self_time_in_ms() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.self_time_in_ms)
  return _internal_self_time_in_ms();
}
inline void InputOpDetails::_internal_set_self_time_in_ms(double value) {
  
  self_time_in_ms_ = value;
}
inline void InputOpDetails::set_self_time_in_ms(double value) {
  _internal_set_self_time_in_ms(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.self_time_in_ms)
}

// double self_time_in_percent = 6;
inline void InputOpDetails::clear_self_time_in_percent() {
  self_time_in_percent_ = 0;
}
inline double InputOpDetails::_internal_self_time_in_percent() const {
  return self_time_in_percent_;
}
inline double InputOpDetails::self_time_in_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.self_time_in_percent)
  return _internal_self_time_in_percent();
}
inline void InputOpDetails::_internal_set_self_time_in_percent(double value) {
  
  self_time_in_percent_ = value;
}
inline void InputOpDetails::set_self_time_in_percent(double value) {
  _internal_set_self_time_in_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.self_time_in_percent)
}

// string category = 7;
inline void InputOpDetails::clear_category() {
  category_.ClearToEmpty();
}
inline const std::string& InputOpDetails::category() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputOpDetails.category)
  return _internal_category();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputOpDetails::set_category(ArgT0&& arg0, ArgT... args) {
 
 category_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputOpDetails.category)
}
inline std::string* InputOpDetails::mutable_category() {
  std::string* _s = _internal_mutable_category();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputOpDetails.category)
  return _s;
}
inline const std::string& InputOpDetails::_internal_category() const {
  return category_.Get();
}
inline void InputOpDetails::_internal_set_category(const std::string& value) {
  
  category_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* InputOpDetails::_internal_mutable_category() {
  
  return category_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* InputOpDetails::release_category() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputOpDetails.category)
  return category_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void InputOpDetails::set_allocated_category(std::string* category) {
  if (category != nullptr) {
    
  } else {
    
  }
  category_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), category,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (category_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    category_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputOpDetails.category)
}

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

// InputPipelineAnalysisRecommendation

// repeated string details = 1;
inline int InputPipelineAnalysisRecommendation::_internal_details_size() const {
  return details_.size();
}
inline int InputPipelineAnalysisRecommendation::details_size() const {
  return _internal_details_size();
}
inline void InputPipelineAnalysisRecommendation::clear_details() {
  details_.Clear();
}
inline std::string* InputPipelineAnalysisRecommendation::add_details() {
  std::string* _s = _internal_add_details();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
  return _s;
}
inline const std::string& InputPipelineAnalysisRecommendation::_internal_details(int index) const {
  return details_.Get(index);
}
inline const std::string& InputPipelineAnalysisRecommendation::details(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
  return _internal_details(index);
}
inline std::string* InputPipelineAnalysisRecommendation::mutable_details(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
  return details_.Mutable(index);
}
inline void InputPipelineAnalysisRecommendation::set_details(int index, const std::string& value) {
  details_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::set_details(int index, std::string&& value) {
  details_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::set_details(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  details_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::set_details(int index, const char* value, size_t size) {
  details_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline std::string* InputPipelineAnalysisRecommendation::_internal_add_details() {
  return details_.Add();
}
inline void InputPipelineAnalysisRecommendation::add_details(const std::string& value) {
  details_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::add_details(std::string&& value) {
  details_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::add_details(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  details_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline void InputPipelineAnalysisRecommendation::add_details(const char* value, size_t size) {
  details_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
InputPipelineAnalysisRecommendation::details() const {
  // @@protoc_insertion_point(field_list:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
  return details_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
InputPipelineAnalysisRecommendation::mutable_details() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.profiler.InputPipelineAnalysisRecommendation.details)
  return &details_;
}

// .google.protobuf.Any bottleneck_analysis = 2;
inline bool InputPipelineAnalysisRecommendation::_internal_has_bottleneck_analysis() const {
  return this != internal_default_instance() && bottleneck_analysis_ != nullptr;
}
inline bool InputPipelineAnalysisRecommendation::has_bottleneck_analysis() const {
  return _internal_has_bottleneck_analysis();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisRecommendation::_internal_bottleneck_analysis() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = bottleneck_analysis_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisRecommendation::bottleneck_analysis() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisRecommendation.bottleneck_analysis)
  return _internal_bottleneck_analysis();
}
inline void InputPipelineAnalysisRecommendation::unsafe_arena_set_allocated_bottleneck_analysis(
    ::PROTOBUF_NAMESPACE_ID::Any* bottleneck_analysis) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bottleneck_analysis_);
  }
  bottleneck_analysis_ = bottleneck_analysis;
  if (bottleneck_analysis) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisRecommendation.bottleneck_analysis)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisRecommendation::release_bottleneck_analysis() {
  
  ::PROTOBUF_NAMESPACE_ID::Any* temp = bottleneck_analysis_;
  bottleneck_analysis_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisRecommendation::unsafe_arena_release_bottleneck_analysis() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisRecommendation.bottleneck_analysis)
  
  ::PROTOBUF_NAMESPACE_ID::Any* temp = bottleneck_analysis_;
  bottleneck_analysis_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisRecommendation::_internal_mutable_bottleneck_analysis() {
  
  if (bottleneck_analysis_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    bottleneck_analysis_ = p;
  }
  return bottleneck_analysis_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisRecommendation::mutable_bottleneck_analysis() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_bottleneck_analysis();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisRecommendation.bottleneck_analysis)
  return _msg;
}
inline void InputPipelineAnalysisRecommendation::set_allocated_bottleneck_analysis(::PROTOBUF_NAMESPACE_ID::Any* bottleneck_analysis) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(bottleneck_analysis_);
  }
  if (bottleneck_analysis) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bottleneck_analysis));
    if (message_arena != submessage_arena) {
      bottleneck_analysis = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bottleneck_analysis, submessage_arena);
    }
    
  } else {
    
  }
  bottleneck_analysis_ = bottleneck_analysis;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisRecommendation.bottleneck_analysis)
}

// string summary_next_step = 3;
inline void InputPipelineAnalysisRecommendation::clear_summary_next_step() {
  summary_next_step_.ClearToEmpty();
}
inline const std::string& InputPipelineAnalysisRecommendation::summary_next_step() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisRecommendation.summary_next_step)
  return _internal_summary_next_step();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputPipelineAnalysisRecommendation::set_summary_next_step(ArgT0&& arg0, ArgT... args) {
 
 summary_next_step_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisRecommendation.summary_next_step)
}
inline std::string* InputPipelineAnalysisRecommendation::mutable_summary_next_step() {
  std::string* _s = _internal_mutable_summary_next_step();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisRecommendation.summary_next_step)
  return _s;
}
inline const std::string& InputPipelineAnalysisRecommendation::_internal_summary_next_step() const {
  return summary_next_step_.Get();
}
inline void InputPipelineAnalysisRecommendation::_internal_set_summary_next_step(const std::string& value) {
  
  summary_next_step_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* InputPipelineAnalysisRecommendation::_internal_mutable_summary_next_step() {
  
  return summary_next_step_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* InputPipelineAnalysisRecommendation::release_summary_next_step() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisRecommendation.summary_next_step)
  return summary_next_step_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void InputPipelineAnalysisRecommendation::set_allocated_summary_next_step(std::string* summary_next_step) {
  if (summary_next_step != nullptr) {
    
  } else {
    
  }
  summary_next_step_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), summary_next_step,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (summary_next_step_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    summary_next_step_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisRecommendation.summary_next_step)
}

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

// GenericStepTimeBreakdown

// .tensorflow.profiler.StepSummary unknown_time_ms_summary = 1;
inline bool GenericStepTimeBreakdown::_internal_has_unknown_time_ms_summary() const {
  return this != internal_default_instance() && unknown_time_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_unknown_time_ms_summary() const {
  return _internal_has_unknown_time_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_unknown_time_ms_summary() {
  if (GetArenaForAllocation() == nullptr && unknown_time_ms_summary_ != nullptr) {
    delete unknown_time_ms_summary_;
  }
  unknown_time_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_unknown_time_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = unknown_time_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::unknown_time_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.unknown_time_ms_summary)
  return _internal_unknown_time_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_unknown_time_ms_summary(
    ::tensorflow::profiler::StepSummary* unknown_time_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(unknown_time_ms_summary_);
  }
  unknown_time_ms_summary_ = unknown_time_ms_summary;
  if (unknown_time_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.unknown_time_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_unknown_time_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = unknown_time_ms_summary_;
  unknown_time_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_unknown_time_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.unknown_time_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = unknown_time_ms_summary_;
  unknown_time_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_unknown_time_ms_summary() {
  
  if (unknown_time_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    unknown_time_ms_summary_ = p;
  }
  return unknown_time_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_unknown_time_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_unknown_time_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.unknown_time_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_unknown_time_ms_summary(::tensorflow::profiler::StepSummary* unknown_time_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete unknown_time_ms_summary_;
  }
  if (unknown_time_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(unknown_time_ms_summary);
    if (message_arena != submessage_arena) {
      unknown_time_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unknown_time_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  unknown_time_ms_summary_ = unknown_time_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.unknown_time_ms_summary)
}

// .tensorflow.profiler.StepSummary host_wait_input_ms_summary = 9;
inline bool GenericStepTimeBreakdown::_internal_has_host_wait_input_ms_summary() const {
  return this != internal_default_instance() && host_wait_input_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_host_wait_input_ms_summary() const {
  return _internal_has_host_wait_input_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_host_wait_input_ms_summary() {
  if (GetArenaForAllocation() == nullptr && host_wait_input_ms_summary_ != nullptr) {
    delete host_wait_input_ms_summary_;
  }
  host_wait_input_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_host_wait_input_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = host_wait_input_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::host_wait_input_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.host_wait_input_ms_summary)
  return _internal_host_wait_input_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_host_wait_input_ms_summary(
    ::tensorflow::profiler::StepSummary* host_wait_input_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_wait_input_ms_summary_);
  }
  host_wait_input_ms_summary_ = host_wait_input_ms_summary;
  if (host_wait_input_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_wait_input_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_host_wait_input_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = host_wait_input_ms_summary_;
  host_wait_input_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_host_wait_input_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.host_wait_input_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = host_wait_input_ms_summary_;
  host_wait_input_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_host_wait_input_ms_summary() {
  
  if (host_wait_input_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    host_wait_input_ms_summary_ = p;
  }
  return host_wait_input_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_host_wait_input_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_host_wait_input_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.host_wait_input_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_host_wait_input_ms_summary(::tensorflow::profiler::StepSummary* host_wait_input_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete host_wait_input_ms_summary_;
  }
  if (host_wait_input_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(host_wait_input_ms_summary);
    if (message_arena != submessage_arena) {
      host_wait_input_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_wait_input_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  host_wait_input_ms_summary_ = host_wait_input_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_wait_input_ms_summary)
}

// .tensorflow.profiler.StepSummary host_to_device_ms_summary = 10;
inline bool GenericStepTimeBreakdown::_internal_has_host_to_device_ms_summary() const {
  return this != internal_default_instance() && host_to_device_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_host_to_device_ms_summary() const {
  return _internal_has_host_to_device_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_host_to_device_ms_summary() {
  if (GetArenaForAllocation() == nullptr && host_to_device_ms_summary_ != nullptr) {
    delete host_to_device_ms_summary_;
  }
  host_to_device_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_host_to_device_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = host_to_device_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::host_to_device_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.host_to_device_ms_summary)
  return _internal_host_to_device_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_host_to_device_ms_summary(
    ::tensorflow::profiler::StepSummary* host_to_device_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_to_device_ms_summary_);
  }
  host_to_device_ms_summary_ = host_to_device_ms_summary;
  if (host_to_device_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_to_device_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_host_to_device_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = host_to_device_ms_summary_;
  host_to_device_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_host_to_device_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.host_to_device_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = host_to_device_ms_summary_;
  host_to_device_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_host_to_device_ms_summary() {
  
  if (host_to_device_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    host_to_device_ms_summary_ = p;
  }
  return host_to_device_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_host_to_device_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_host_to_device_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.host_to_device_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_host_to_device_ms_summary(::tensorflow::profiler::StepSummary* host_to_device_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete host_to_device_ms_summary_;
  }
  if (host_to_device_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(host_to_device_ms_summary);
    if (message_arena != submessage_arena) {
      host_to_device_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_to_device_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  host_to_device_ms_summary_ = host_to_device_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_to_device_ms_summary)
}

// .tensorflow.profiler.StepSummary input_ms_summary = 11;
inline bool GenericStepTimeBreakdown::_internal_has_input_ms_summary() const {
  return this != internal_default_instance() && input_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_input_ms_summary() const {
  return _internal_has_input_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_input_ms_summary() {
  if (GetArenaForAllocation() == nullptr && input_ms_summary_ != nullptr) {
    delete input_ms_summary_;
  }
  input_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_input_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = input_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::input_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.input_ms_summary)
  return _internal_input_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_input_ms_summary(
    ::tensorflow::profiler::StepSummary* input_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_ms_summary_);
  }
  input_ms_summary_ = input_ms_summary;
  if (input_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.input_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_input_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = input_ms_summary_;
  input_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_input_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.input_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = input_ms_summary_;
  input_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_input_ms_summary() {
  
  if (input_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    input_ms_summary_ = p;
  }
  return input_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_input_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_input_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.input_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_input_ms_summary(::tensorflow::profiler::StepSummary* input_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete input_ms_summary_;
  }
  if (input_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(input_ms_summary);
    if (message_arena != submessage_arena) {
      input_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, input_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  input_ms_summary_ = input_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.input_ms_summary)
}

// .tensorflow.profiler.StepSummary output_ms_summary = 3;
inline bool GenericStepTimeBreakdown::_internal_has_output_ms_summary() const {
  return this != internal_default_instance() && output_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_output_ms_summary() const {
  return _internal_has_output_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_output_ms_summary() {
  if (GetArenaForAllocation() == nullptr && output_ms_summary_ != nullptr) {
    delete output_ms_summary_;
  }
  output_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_output_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = output_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::output_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.output_ms_summary)
  return _internal_output_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_output_ms_summary(
    ::tensorflow::profiler::StepSummary* output_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_ms_summary_);
  }
  output_ms_summary_ = output_ms_summary;
  if (output_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.output_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_output_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = output_ms_summary_;
  output_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_output_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.output_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = output_ms_summary_;
  output_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_output_ms_summary() {
  
  if (output_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    output_ms_summary_ = p;
  }
  return output_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_output_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_output_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.output_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_output_ms_summary(::tensorflow::profiler::StepSummary* output_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete output_ms_summary_;
  }
  if (output_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(output_ms_summary);
    if (message_arena != submessage_arena) {
      output_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  output_ms_summary_ = output_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.output_ms_summary)
}

// .tensorflow.profiler.StepSummary device_compute_ms_summary = 4;
inline bool GenericStepTimeBreakdown::_internal_has_device_compute_ms_summary() const {
  return this != internal_default_instance() && device_compute_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_device_compute_ms_summary() const {
  return _internal_has_device_compute_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_device_compute_ms_summary() {
  if (GetArenaForAllocation() == nullptr && device_compute_ms_summary_ != nullptr) {
    delete device_compute_ms_summary_;
  }
  device_compute_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_device_compute_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = device_compute_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::device_compute_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.device_compute_ms_summary)
  return _internal_device_compute_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_device_compute_ms_summary(
    ::tensorflow::profiler::StepSummary* device_compute_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_compute_ms_summary_);
  }
  device_compute_ms_summary_ = device_compute_ms_summary;
  if (device_compute_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_compute_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_device_compute_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = device_compute_ms_summary_;
  device_compute_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_device_compute_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.device_compute_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = device_compute_ms_summary_;
  device_compute_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_device_compute_ms_summary() {
  
  if (device_compute_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    device_compute_ms_summary_ = p;
  }
  return device_compute_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_device_compute_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_device_compute_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.device_compute_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_device_compute_ms_summary(::tensorflow::profiler::StepSummary* device_compute_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete device_compute_ms_summary_;
  }
  if (device_compute_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(device_compute_ms_summary);
    if (message_arena != submessage_arena) {
      device_compute_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_compute_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  device_compute_ms_summary_ = device_compute_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_compute_ms_summary)
}

// .tensorflow.profiler.StepSummary device_to_device_ms_summary = 5;
inline bool GenericStepTimeBreakdown::_internal_has_device_to_device_ms_summary() const {
  return this != internal_default_instance() && device_to_device_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_device_to_device_ms_summary() const {
  return _internal_has_device_to_device_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_device_to_device_ms_summary() {
  if (GetArenaForAllocation() == nullptr && device_to_device_ms_summary_ != nullptr) {
    delete device_to_device_ms_summary_;
  }
  device_to_device_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_device_to_device_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = device_to_device_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::device_to_device_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.device_to_device_ms_summary)
  return _internal_device_to_device_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_device_to_device_ms_summary(
    ::tensorflow::profiler::StepSummary* device_to_device_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_to_device_ms_summary_);
  }
  device_to_device_ms_summary_ = device_to_device_ms_summary;
  if (device_to_device_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_to_device_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_device_to_device_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = device_to_device_ms_summary_;
  device_to_device_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_device_to_device_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.device_to_device_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = device_to_device_ms_summary_;
  device_to_device_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_device_to_device_ms_summary() {
  
  if (device_to_device_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    device_to_device_ms_summary_ = p;
  }
  return device_to_device_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_device_to_device_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_device_to_device_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.device_to_device_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_device_to_device_ms_summary(::tensorflow::profiler::StepSummary* device_to_device_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete device_to_device_ms_summary_;
  }
  if (device_to_device_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(device_to_device_ms_summary);
    if (message_arena != submessage_arena) {
      device_to_device_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_to_device_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  device_to_device_ms_summary_ = device_to_device_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_to_device_ms_summary)
}

// .tensorflow.profiler.StepSummary device_collectives_ms_summary = 12;
inline bool GenericStepTimeBreakdown::_internal_has_device_collectives_ms_summary() const {
  return this != internal_default_instance() && device_collectives_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_device_collectives_ms_summary() const {
  return _internal_has_device_collectives_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_device_collectives_ms_summary() {
  if (GetArenaForAllocation() == nullptr && device_collectives_ms_summary_ != nullptr) {
    delete device_collectives_ms_summary_;
  }
  device_collectives_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_device_collectives_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = device_collectives_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::device_collectives_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.device_collectives_ms_summary)
  return _internal_device_collectives_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_device_collectives_ms_summary(
    ::tensorflow::profiler::StepSummary* device_collectives_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_collectives_ms_summary_);
  }
  device_collectives_ms_summary_ = device_collectives_ms_summary;
  if (device_collectives_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_collectives_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_device_collectives_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = device_collectives_ms_summary_;
  device_collectives_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_device_collectives_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.device_collectives_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = device_collectives_ms_summary_;
  device_collectives_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_device_collectives_ms_summary() {
  
  if (device_collectives_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    device_collectives_ms_summary_ = p;
  }
  return device_collectives_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_device_collectives_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_device_collectives_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.device_collectives_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_device_collectives_ms_summary(::tensorflow::profiler::StepSummary* device_collectives_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete device_collectives_ms_summary_;
  }
  if (device_collectives_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(device_collectives_ms_summary);
    if (message_arena != submessage_arena) {
      device_collectives_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_collectives_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  device_collectives_ms_summary_ = device_collectives_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.device_collectives_ms_summary)
}

// .tensorflow.profiler.StepSummary host_compute_ms_summary = 6;
inline bool GenericStepTimeBreakdown::_internal_has_host_compute_ms_summary() const {
  return this != internal_default_instance() && host_compute_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_host_compute_ms_summary() const {
  return _internal_has_host_compute_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_host_compute_ms_summary() {
  if (GetArenaForAllocation() == nullptr && host_compute_ms_summary_ != nullptr) {
    delete host_compute_ms_summary_;
  }
  host_compute_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_host_compute_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = host_compute_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::host_compute_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.host_compute_ms_summary)
  return _internal_host_compute_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_host_compute_ms_summary(
    ::tensorflow::profiler::StepSummary* host_compute_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_compute_ms_summary_);
  }
  host_compute_ms_summary_ = host_compute_ms_summary;
  if (host_compute_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_compute_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_host_compute_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = host_compute_ms_summary_;
  host_compute_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_host_compute_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.host_compute_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = host_compute_ms_summary_;
  host_compute_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_host_compute_ms_summary() {
  
  if (host_compute_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    host_compute_ms_summary_ = p;
  }
  return host_compute_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_host_compute_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_host_compute_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.host_compute_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_host_compute_ms_summary(::tensorflow::profiler::StepSummary* host_compute_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete host_compute_ms_summary_;
  }
  if (host_compute_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(host_compute_ms_summary);
    if (message_arena != submessage_arena) {
      host_compute_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_compute_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  host_compute_ms_summary_ = host_compute_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_compute_ms_summary)
}

// .tensorflow.profiler.StepSummary host_prepare_ms_summary = 7;
inline bool GenericStepTimeBreakdown::_internal_has_host_prepare_ms_summary() const {
  return this != internal_default_instance() && host_prepare_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_host_prepare_ms_summary() const {
  return _internal_has_host_prepare_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_host_prepare_ms_summary() {
  if (GetArenaForAllocation() == nullptr && host_prepare_ms_summary_ != nullptr) {
    delete host_prepare_ms_summary_;
  }
  host_prepare_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_host_prepare_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = host_prepare_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::host_prepare_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.host_prepare_ms_summary)
  return _internal_host_prepare_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_host_prepare_ms_summary(
    ::tensorflow::profiler::StepSummary* host_prepare_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_prepare_ms_summary_);
  }
  host_prepare_ms_summary_ = host_prepare_ms_summary;
  if (host_prepare_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_prepare_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_host_prepare_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = host_prepare_ms_summary_;
  host_prepare_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_host_prepare_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.host_prepare_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = host_prepare_ms_summary_;
  host_prepare_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_host_prepare_ms_summary() {
  
  if (host_prepare_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    host_prepare_ms_summary_ = p;
  }
  return host_prepare_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_host_prepare_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_host_prepare_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.host_prepare_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_host_prepare_ms_summary(::tensorflow::profiler::StepSummary* host_prepare_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete host_prepare_ms_summary_;
  }
  if (host_prepare_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(host_prepare_ms_summary);
    if (message_arena != submessage_arena) {
      host_prepare_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_prepare_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  host_prepare_ms_summary_ = host_prepare_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_prepare_ms_summary)
}

// .tensorflow.profiler.StepSummary host_compile_ms_summary = 8;
inline bool GenericStepTimeBreakdown::_internal_has_host_compile_ms_summary() const {
  return this != internal_default_instance() && host_compile_ms_summary_ != nullptr;
}
inline bool GenericStepTimeBreakdown::has_host_compile_ms_summary() const {
  return _internal_has_host_compile_ms_summary();
}
inline void GenericStepTimeBreakdown::clear_host_compile_ms_summary() {
  if (GetArenaForAllocation() == nullptr && host_compile_ms_summary_ != nullptr) {
    delete host_compile_ms_summary_;
  }
  host_compile_ms_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::_internal_host_compile_ms_summary() const {
  const ::tensorflow::profiler::StepSummary* p = host_compile_ms_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& GenericStepTimeBreakdown::host_compile_ms_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.GenericStepTimeBreakdown.host_compile_ms_summary)
  return _internal_host_compile_ms_summary();
}
inline void GenericStepTimeBreakdown::unsafe_arena_set_allocated_host_compile_ms_summary(
    ::tensorflow::profiler::StepSummary* host_compile_ms_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_compile_ms_summary_);
  }
  host_compile_ms_summary_ = host_compile_ms_summary;
  if (host_compile_ms_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_compile_ms_summary)
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::release_host_compile_ms_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = host_compile_ms_summary_;
  host_compile_ms_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::unsafe_arena_release_host_compile_ms_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.GenericStepTimeBreakdown.host_compile_ms_summary)
  
  ::tensorflow::profiler::StepSummary* temp = host_compile_ms_summary_;
  host_compile_ms_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::_internal_mutable_host_compile_ms_summary() {
  
  if (host_compile_ms_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    host_compile_ms_summary_ = p;
  }
  return host_compile_ms_summary_;
}
inline ::tensorflow::profiler::StepSummary* GenericStepTimeBreakdown::mutable_host_compile_ms_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_host_compile_ms_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.GenericStepTimeBreakdown.host_compile_ms_summary)
  return _msg;
}
inline void GenericStepTimeBreakdown::set_allocated_host_compile_ms_summary(::tensorflow::profiler::StepSummary* host_compile_ms_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete host_compile_ms_summary_;
  }
  if (host_compile_ms_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(host_compile_ms_summary);
    if (message_arena != submessage_arena) {
      host_compile_ms_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_compile_ms_summary, submessage_arena);
    }
    
  } else {
    
  }
  host_compile_ms_summary_ = host_compile_ms_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.GenericStepTimeBreakdown.host_compile_ms_summary)
}

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

// InputPipelineAnalysisResult

// string hardware_type = 9;
inline void InputPipelineAnalysisResult::clear_hardware_type() {
  hardware_type_.ClearToEmpty();
}
inline const std::string& InputPipelineAnalysisResult::hardware_type() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.hardware_type)
  return _internal_hardware_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputPipelineAnalysisResult::set_hardware_type(ArgT0&& arg0, ArgT... args) {
 
 hardware_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisResult.hardware_type)
}
inline std::string* InputPipelineAnalysisResult::mutable_hardware_type() {
  std::string* _s = _internal_mutable_hardware_type();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.hardware_type)
  return _s;
}
inline const std::string& InputPipelineAnalysisResult::_internal_hardware_type() const {
  return hardware_type_.Get();
}
inline void InputPipelineAnalysisResult::_internal_set_hardware_type(const std::string& value) {
  
  hardware_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* InputPipelineAnalysisResult::_internal_mutable_hardware_type() {
  
  return hardware_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* InputPipelineAnalysisResult::release_hardware_type() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.hardware_type)
  return hardware_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void InputPipelineAnalysisResult::set_allocated_hardware_type(std::string* hardware_type) {
  if (hardware_type != nullptr) {
    
  } else {
    
  }
  hardware_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hardware_type,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (hardware_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    hardware_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.hardware_type)
}

// .tensorflow.profiler.StepSummary step_time_summary = 2;
inline bool InputPipelineAnalysisResult::_internal_has_step_time_summary() const {
  return this != internal_default_instance() && step_time_summary_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_step_time_summary() const {
  return _internal_has_step_time_summary();
}
inline void InputPipelineAnalysisResult::clear_step_time_summary() {
  if (GetArenaForAllocation() == nullptr && step_time_summary_ != nullptr) {
    delete step_time_summary_;
  }
  step_time_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& InputPipelineAnalysisResult::_internal_step_time_summary() const {
  const ::tensorflow::profiler::StepSummary* p = step_time_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& InputPipelineAnalysisResult::step_time_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.step_time_summary)
  return _internal_step_time_summary();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_step_time_summary(
    ::tensorflow::profiler::StepSummary* step_time_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_time_summary_);
  }
  step_time_summary_ = step_time_summary;
  if (step_time_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.step_time_summary)
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::release_step_time_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = step_time_summary_;
  step_time_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::unsafe_arena_release_step_time_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.step_time_summary)
  
  ::tensorflow::profiler::StepSummary* temp = step_time_summary_;
  step_time_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::_internal_mutable_step_time_summary() {
  
  if (step_time_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    step_time_summary_ = p;
  }
  return step_time_summary_;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::mutable_step_time_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_step_time_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.step_time_summary)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_step_time_summary(::tensorflow::profiler::StepSummary* step_time_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete step_time_summary_;
  }
  if (step_time_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(step_time_summary);
    if (message_arena != submessage_arena) {
      step_time_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, step_time_summary, submessage_arena);
    }
    
  } else {
    
  }
  step_time_summary_ = step_time_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.step_time_summary)
}

// .tensorflow.profiler.StepSummary input_percent_summary = 3;
inline bool InputPipelineAnalysisResult::_internal_has_input_percent_summary() const {
  return this != internal_default_instance() && input_percent_summary_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_input_percent_summary() const {
  return _internal_has_input_percent_summary();
}
inline void InputPipelineAnalysisResult::clear_input_percent_summary() {
  if (GetArenaForAllocation() == nullptr && input_percent_summary_ != nullptr) {
    delete input_percent_summary_;
  }
  input_percent_summary_ = nullptr;
}
inline const ::tensorflow::profiler::StepSummary& InputPipelineAnalysisResult::_internal_input_percent_summary() const {
  const ::tensorflow::profiler::StepSummary* p = input_percent_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::StepSummary&>(
      ::tensorflow::profiler::_StepSummary_default_instance_);
}
inline const ::tensorflow::profiler::StepSummary& InputPipelineAnalysisResult::input_percent_summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.input_percent_summary)
  return _internal_input_percent_summary();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_input_percent_summary(
    ::tensorflow::profiler::StepSummary* input_percent_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_percent_summary_);
  }
  input_percent_summary_ = input_percent_summary;
  if (input_percent_summary) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.input_percent_summary)
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::release_input_percent_summary() {
  
  ::tensorflow::profiler::StepSummary* temp = input_percent_summary_;
  input_percent_summary_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::unsafe_arena_release_input_percent_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.input_percent_summary)
  
  ::tensorflow::profiler::StepSummary* temp = input_percent_summary_;
  input_percent_summary_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::_internal_mutable_input_percent_summary() {
  
  if (input_percent_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::StepSummary>(GetArenaForAllocation());
    input_percent_summary_ = p;
  }
  return input_percent_summary_;
}
inline ::tensorflow::profiler::StepSummary* InputPipelineAnalysisResult::mutable_input_percent_summary() {
  ::tensorflow::profiler::StepSummary* _msg = _internal_mutable_input_percent_summary();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.input_percent_summary)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_input_percent_summary(::tensorflow::profiler::StepSummary* input_percent_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete input_percent_summary_;
  }
  if (input_percent_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::StepSummary>::GetOwningArena(input_percent_summary);
    if (message_arena != submessage_arena) {
      input_percent_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, input_percent_summary, submessage_arena);
    }
    
  } else {
    
  }
  input_percent_summary_ = input_percent_summary;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.input_percent_summary)
}

// double input_percent = 11;
inline void InputPipelineAnalysisResult::clear_input_percent() {
  input_percent_ = 0;
}
inline double InputPipelineAnalysisResult::_internal_input_percent() const {
  return input_percent_;
}
inline double InputPipelineAnalysisResult::input_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.input_percent)
  return _internal_input_percent();
}
inline void InputPipelineAnalysisResult::_internal_set_input_percent(double value) {
  
  input_percent_ = value;
}
inline void InputPipelineAnalysisResult::set_input_percent(double value) {
  _internal_set_input_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisResult.input_percent)
}

// double output_percent = 13;
inline void InputPipelineAnalysisResult::clear_output_percent() {
  output_percent_ = 0;
}
inline double InputPipelineAnalysisResult::_internal_output_percent() const {
  return output_percent_;
}
inline double InputPipelineAnalysisResult::output_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.output_percent)
  return _internal_output_percent();
}
inline void InputPipelineAnalysisResult::_internal_set_output_percent(double value) {
  
  output_percent_ = value;
}
inline void InputPipelineAnalysisResult::set_output_percent(double value) {
  _internal_set_output_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisResult.output_percent)
}

// double idle_percent = 14;
inline void InputPipelineAnalysisResult::clear_idle_percent() {
  idle_percent_ = 0;
}
inline double InputPipelineAnalysisResult::_internal_idle_percent() const {
  return idle_percent_;
}
inline double InputPipelineAnalysisResult::idle_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.idle_percent)
  return _internal_idle_percent();
}
inline void InputPipelineAnalysisResult::_internal_set_idle_percent(double value) {
  
  idle_percent_ = value;
}
inline void InputPipelineAnalysisResult::set_idle_percent(double value) {
  _internal_set_idle_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisResult.idle_percent)
}

// double compute_percent = 15;
inline void InputPipelineAnalysisResult::clear_compute_percent() {
  compute_percent_ = 0;
}
inline double InputPipelineAnalysisResult::_internal_compute_percent() const {
  return compute_percent_;
}
inline double InputPipelineAnalysisResult::compute_percent() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.compute_percent)
  return _internal_compute_percent();
}
inline void InputPipelineAnalysisResult::_internal_set_compute_percent(double value) {
  
  compute_percent_ = value;
}
inline void InputPipelineAnalysisResult::set_compute_percent(double value) {
  _internal_set_compute_percent(value);
  // @@protoc_insertion_point(field_set:tensorflow.profiler.InputPipelineAnalysisResult.compute_percent)
}

// repeated .google.protobuf.Any step_details = 4;
inline int InputPipelineAnalysisResult::_internal_step_details_size() const {
  return step_details_.size();
}
inline int InputPipelineAnalysisResult::step_details_size() const {
  return _internal_step_details_size();
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::mutable_step_details(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.step_details)
  return step_details_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >*
InputPipelineAnalysisResult::mutable_step_details() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.profiler.InputPipelineAnalysisResult.step_details)
  return &step_details_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisResult::_internal_step_details(int index) const {
  return step_details_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisResult::step_details(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.step_details)
  return _internal_step_details(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::_internal_add_step_details() {
  return step_details_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::add_step_details() {
  ::PROTOBUF_NAMESPACE_ID::Any* _add = _internal_add_step_details();
  // @@protoc_insertion_point(field_add:tensorflow.profiler.InputPipelineAnalysisResult.step_details)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >&
InputPipelineAnalysisResult::step_details() const {
  // @@protoc_insertion_point(field_list:tensorflow.profiler.InputPipelineAnalysisResult.step_details)
  return step_details_;
}

// .tensorflow.profiler.InputTimeBreakdown input_time_breakdown = 5;
inline bool InputPipelineAnalysisResult::_internal_has_input_time_breakdown() const {
  return this != internal_default_instance() && input_time_breakdown_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_input_time_breakdown() const {
  return _internal_has_input_time_breakdown();
}
inline void InputPipelineAnalysisResult::clear_input_time_breakdown() {
  if (GetArenaForAllocation() == nullptr && input_time_breakdown_ != nullptr) {
    delete input_time_breakdown_;
  }
  input_time_breakdown_ = nullptr;
}
inline const ::tensorflow::profiler::InputTimeBreakdown& InputPipelineAnalysisResult::_internal_input_time_breakdown() const {
  const ::tensorflow::profiler::InputTimeBreakdown* p = input_time_breakdown_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::InputTimeBreakdown&>(
      ::tensorflow::profiler::_InputTimeBreakdown_default_instance_);
}
inline const ::tensorflow::profiler::InputTimeBreakdown& InputPipelineAnalysisResult::input_time_breakdown() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.input_time_breakdown)
  return _internal_input_time_breakdown();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_input_time_breakdown(
    ::tensorflow::profiler::InputTimeBreakdown* input_time_breakdown) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_time_breakdown_);
  }
  input_time_breakdown_ = input_time_breakdown;
  if (input_time_breakdown) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.input_time_breakdown)
}
inline ::tensorflow::profiler::InputTimeBreakdown* InputPipelineAnalysisResult::release_input_time_breakdown() {
  
  ::tensorflow::profiler::InputTimeBreakdown* temp = input_time_breakdown_;
  input_time_breakdown_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::InputTimeBreakdown* InputPipelineAnalysisResult::unsafe_arena_release_input_time_breakdown() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.input_time_breakdown)
  
  ::tensorflow::profiler::InputTimeBreakdown* temp = input_time_breakdown_;
  input_time_breakdown_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::InputTimeBreakdown* InputPipelineAnalysisResult::_internal_mutable_input_time_breakdown() {
  
  if (input_time_breakdown_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::InputTimeBreakdown>(GetArenaForAllocation());
    input_time_breakdown_ = p;
  }
  return input_time_breakdown_;
}
inline ::tensorflow::profiler::InputTimeBreakdown* InputPipelineAnalysisResult::mutable_input_time_breakdown() {
  ::tensorflow::profiler::InputTimeBreakdown* _msg = _internal_mutable_input_time_breakdown();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.input_time_breakdown)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_input_time_breakdown(::tensorflow::profiler::InputTimeBreakdown* input_time_breakdown) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete input_time_breakdown_;
  }
  if (input_time_breakdown) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::InputTimeBreakdown>::GetOwningArena(input_time_breakdown);
    if (message_arena != submessage_arena) {
      input_time_breakdown = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, input_time_breakdown, submessage_arena);
    }
    
  } else {
    
  }
  input_time_breakdown_ = input_time_breakdown;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.input_time_breakdown)
}

// repeated .tensorflow.profiler.InputOpDetails input_op_details = 6;
inline int InputPipelineAnalysisResult::_internal_input_op_details_size() const {
  return input_op_details_.size();
}
inline int InputPipelineAnalysisResult::input_op_details_size() const {
  return _internal_input_op_details_size();
}
inline void InputPipelineAnalysisResult::clear_input_op_details() {
  input_op_details_.Clear();
}
inline ::tensorflow::profiler::InputOpDetails* InputPipelineAnalysisResult::mutable_input_op_details(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.input_op_details)
  return input_op_details_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::profiler::InputOpDetails >*
InputPipelineAnalysisResult::mutable_input_op_details() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.profiler.InputPipelineAnalysisResult.input_op_details)
  return &input_op_details_;
}
inline const ::tensorflow::profiler::InputOpDetails& InputPipelineAnalysisResult::_internal_input_op_details(int index) const {
  return input_op_details_.Get(index);
}
inline const ::tensorflow::profiler::InputOpDetails& InputPipelineAnalysisResult::input_op_details(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.input_op_details)
  return _internal_input_op_details(index);
}
inline ::tensorflow::profiler::InputOpDetails* InputPipelineAnalysisResult::_internal_add_input_op_details() {
  return input_op_details_.Add();
}
inline ::tensorflow::profiler::InputOpDetails* InputPipelineAnalysisResult::add_input_op_details() {
  ::tensorflow::profiler::InputOpDetails* _add = _internal_add_input_op_details();
  // @@protoc_insertion_point(field_add:tensorflow.profiler.InputPipelineAnalysisResult.input_op_details)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::profiler::InputOpDetails >&
InputPipelineAnalysisResult::input_op_details() const {
  // @@protoc_insertion_point(field_list:tensorflow.profiler.InputPipelineAnalysisResult.input_op_details)
  return input_op_details_;
}

// .tensorflow.profiler.InputPipelineAnalysisRecommendation recommendation = 7;
inline bool InputPipelineAnalysisResult::_internal_has_recommendation() const {
  return this != internal_default_instance() && recommendation_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_recommendation() const {
  return _internal_has_recommendation();
}
inline void InputPipelineAnalysisResult::clear_recommendation() {
  if (GetArenaForAllocation() == nullptr && recommendation_ != nullptr) {
    delete recommendation_;
  }
  recommendation_ = nullptr;
}
inline const ::tensorflow::profiler::InputPipelineAnalysisRecommendation& InputPipelineAnalysisResult::_internal_recommendation() const {
  const ::tensorflow::profiler::InputPipelineAnalysisRecommendation* p = recommendation_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::InputPipelineAnalysisRecommendation&>(
      ::tensorflow::profiler::_InputPipelineAnalysisRecommendation_default_instance_);
}
inline const ::tensorflow::profiler::InputPipelineAnalysisRecommendation& InputPipelineAnalysisResult::recommendation() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.recommendation)
  return _internal_recommendation();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_recommendation(
    ::tensorflow::profiler::InputPipelineAnalysisRecommendation* recommendation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(recommendation_);
  }
  recommendation_ = recommendation;
  if (recommendation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.recommendation)
}
inline ::tensorflow::profiler::InputPipelineAnalysisRecommendation* InputPipelineAnalysisResult::release_recommendation() {
  
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* temp = recommendation_;
  recommendation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::InputPipelineAnalysisRecommendation* InputPipelineAnalysisResult::unsafe_arena_release_recommendation() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.recommendation)
  
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* temp = recommendation_;
  recommendation_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::InputPipelineAnalysisRecommendation* InputPipelineAnalysisResult::_internal_mutable_recommendation() {
  
  if (recommendation_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::InputPipelineAnalysisRecommendation>(GetArenaForAllocation());
    recommendation_ = p;
  }
  return recommendation_;
}
inline ::tensorflow::profiler::InputPipelineAnalysisRecommendation* InputPipelineAnalysisResult::mutable_recommendation() {
  ::tensorflow::profiler::InputPipelineAnalysisRecommendation* _msg = _internal_mutable_recommendation();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.recommendation)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_recommendation(::tensorflow::profiler::InputPipelineAnalysisRecommendation* recommendation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete recommendation_;
  }
  if (recommendation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::profiler::InputPipelineAnalysisRecommendation>::GetOwningArena(recommendation);
    if (message_arena != submessage_arena) {
      recommendation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recommendation, submessage_arena);
    }
    
  } else {
    
  }
  recommendation_ = recommendation;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.recommendation)
}

// .google.protobuf.Any step_time_breakdown = 8;
inline bool InputPipelineAnalysisResult::_internal_has_step_time_breakdown() const {
  return this != internal_default_instance() && step_time_breakdown_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_step_time_breakdown() const {
  return _internal_has_step_time_breakdown();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisResult::_internal_step_time_breakdown() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = step_time_breakdown_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& InputPipelineAnalysisResult::step_time_breakdown() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.step_time_breakdown)
  return _internal_step_time_breakdown();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_step_time_breakdown(
    ::PROTOBUF_NAMESPACE_ID::Any* step_time_breakdown) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_time_breakdown_);
  }
  step_time_breakdown_ = step_time_breakdown;
  if (step_time_breakdown) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.step_time_breakdown)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::release_step_time_breakdown() {
  
  ::PROTOBUF_NAMESPACE_ID::Any* temp = step_time_breakdown_;
  step_time_breakdown_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::unsafe_arena_release_step_time_breakdown() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.step_time_breakdown)
  
  ::PROTOBUF_NAMESPACE_ID::Any* temp = step_time_breakdown_;
  step_time_breakdown_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::_internal_mutable_step_time_breakdown() {
  
  if (step_time_breakdown_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    step_time_breakdown_ = p;
  }
  return step_time_breakdown_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* InputPipelineAnalysisResult::mutable_step_time_breakdown() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_step_time_breakdown();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.step_time_breakdown)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_step_time_breakdown(::PROTOBUF_NAMESPACE_ID::Any* step_time_breakdown) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_time_breakdown_);
  }
  if (step_time_breakdown) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_time_breakdown));
    if (message_arena != submessage_arena) {
      step_time_breakdown = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, step_time_breakdown, submessage_arena);
    }
    
  } else {
    
  }
  step_time_breakdown_ = step_time_breakdown;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.step_time_breakdown)
}

// .tensorflow.profiler.Diagnostics diagnostics = 12;
inline bool InputPipelineAnalysisResult::_internal_has_diagnostics() const {
  return this != internal_default_instance() && diagnostics_ != nullptr;
}
inline bool InputPipelineAnalysisResult::has_diagnostics() const {
  return _internal_has_diagnostics();
}
inline const ::tensorflow::profiler::Diagnostics& InputPipelineAnalysisResult::_internal_diagnostics() const {
  const ::tensorflow::profiler::Diagnostics* p = diagnostics_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::profiler::Diagnostics&>(
      ::tensorflow::profiler::_Diagnostics_default_instance_);
}
inline const ::tensorflow::profiler::Diagnostics& InputPipelineAnalysisResult::diagnostics() const {
  // @@protoc_insertion_point(field_get:tensorflow.profiler.InputPipelineAnalysisResult.diagnostics)
  return _internal_diagnostics();
}
inline void InputPipelineAnalysisResult::unsafe_arena_set_allocated_diagnostics(
    ::tensorflow::profiler::Diagnostics* diagnostics) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagnostics_);
  }
  diagnostics_ = diagnostics;
  if (diagnostics) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.diagnostics)
}
inline ::tensorflow::profiler::Diagnostics* InputPipelineAnalysisResult::release_diagnostics() {
  
  ::tensorflow::profiler::Diagnostics* temp = diagnostics_;
  diagnostics_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::profiler::Diagnostics* InputPipelineAnalysisResult::unsafe_arena_release_diagnostics() {
  // @@protoc_insertion_point(field_release:tensorflow.profiler.InputPipelineAnalysisResult.diagnostics)
  
  ::tensorflow::profiler::Diagnostics* temp = diagnostics_;
  diagnostics_ = nullptr;
  return temp;
}
inline ::tensorflow::profiler::Diagnostics* InputPipelineAnalysisResult::_internal_mutable_diagnostics() {
  
  if (diagnostics_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::profiler::Diagnostics>(GetArenaForAllocation());
    diagnostics_ = p;
  }
  return diagnostics_;
}
inline ::tensorflow::profiler::Diagnostics* InputPipelineAnalysisResult::mutable_diagnostics() {
  ::tensorflow::profiler::Diagnostics* _msg = _internal_mutable_diagnostics();
  // @@protoc_insertion_point(field_mutable:tensorflow.profiler.InputPipelineAnalysisResult.diagnostics)
  return _msg;
}
inline void InputPipelineAnalysisResult::set_allocated_diagnostics(::tensorflow::profiler::Diagnostics* diagnostics) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagnostics_);
  }
  if (diagnostics) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagnostics));
    if (message_arena != submessage_arena) {
      diagnostics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagnostics, submessage_arena);
    }
    
  } else {
    
  }
  diagnostics_ = diagnostics;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.profiler.InputPipelineAnalysisResult.diagnostics)
}

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace profiler
}  // namespace tensorflow

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprofiler_2fprotobuf_2finput_5fpipeline_2eproto
