xref: /aosp_15_r20/out/soong/.intermediates/external/tensorflow/tensorflow_core_proto_cpp_lite/android_arm64_armv8-2a_cortex-a55_static_apex33/gen/proto/tensorflow/core/protobuf/worker.pb.cc

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

#include "tensorflow/core/protobuf/worker.pb.h"

#include <algorithm>
#include <cstdint>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

namespace tensorflow {
PROTOBUF_CONSTEXPR GetStatusRequest::GetStatusRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetStatusRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetStatusRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetStatusRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    GetStatusRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetStatusRequestDefaultTypeInternal _GetStatusRequest_default_instance_;
PROTOBUF_CONSTEXPR GetStatusResponse::GetStatusResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.device_attributes_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetStatusResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetStatusResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetStatusResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    GetStatusResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetStatusResponseDefaultTypeInternal _GetStatusResponse_default_instance_;
PROTOBUF_CONSTEXPR CreateWorkerSessionRequest::CreateWorkerSessionRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.cluster_device_attributes_)*/{}
  , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.master_task_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.server_def_)*/nullptr
  , /*decltype(_impl_.master_incarnation_)*/::int64_t{0}
  , /*decltype(_impl_.isolate_session_state_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CreateWorkerSessionRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CreateWorkerSessionRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CreateWorkerSessionRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CreateWorkerSessionRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateWorkerSessionRequestDefaultTypeInternal _CreateWorkerSessionRequest_default_instance_;
PROTOBUF_CONSTEXPR CreateWorkerSessionResponse::CreateWorkerSessionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CreateWorkerSessionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CreateWorkerSessionResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CreateWorkerSessionResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CreateWorkerSessionResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateWorkerSessionResponseDefaultTypeInternal _CreateWorkerSessionResponse_default_instance_;
PROTOBUF_CONSTEXPR DeleteWorkerSessionRequest::DeleteWorkerSessionRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteWorkerSessionRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteWorkerSessionRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteWorkerSessionRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    DeleteWorkerSessionRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteWorkerSessionRequestDefaultTypeInternal _DeleteWorkerSessionRequest_default_instance_;
PROTOBUF_CONSTEXPR DeleteWorkerSessionResponse::DeleteWorkerSessionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteWorkerSessionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteWorkerSessionResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteWorkerSessionResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    DeleteWorkerSessionResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteWorkerSessionResponseDefaultTypeInternal _DeleteWorkerSessionResponse_default_instance_;
PROTOBUF_CONSTEXPR RegisterGraphRequest::RegisterGraphRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.graph_def_)*/nullptr
  , /*decltype(_impl_.graph_options_)*/nullptr
  , /*decltype(_impl_.debug_options_)*/nullptr
  , /*decltype(_impl_.config_proto_)*/nullptr
  , /*decltype(_impl_.collective_graph_key_)*/::int64_t{0}
  , /*decltype(_impl_.create_worker_session_called_)*/false
  , /*decltype(_impl_.has_control_flow_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RegisterGraphRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RegisterGraphRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RegisterGraphRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RegisterGraphRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterGraphRequestDefaultTypeInternal _RegisterGraphRequest_default_instance_;
PROTOBUF_CONSTEXPR RegisterGraphResponse::RegisterGraphResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.graph_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RegisterGraphResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RegisterGraphResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RegisterGraphResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RegisterGraphResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterGraphResponseDefaultTypeInternal _RegisterGraphResponse_default_instance_;
PROTOBUF_CONSTEXPR DeregisterGraphRequest::DeregisterGraphRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.graph_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.create_worker_session_called_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DeregisterGraphRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeregisterGraphRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeregisterGraphRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    DeregisterGraphRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeregisterGraphRequestDefaultTypeInternal _DeregisterGraphRequest_default_instance_;
PROTOBUF_CONSTEXPR DeregisterGraphResponse::DeregisterGraphResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeregisterGraphResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeregisterGraphResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeregisterGraphResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    DeregisterGraphResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeregisterGraphResponseDefaultTypeInternal _DeregisterGraphResponse_default_instance_;
PROTOBUF_CONSTEXPR CleanupAllRequest::CleanupAllRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.container_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CleanupAllRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CleanupAllRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CleanupAllRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CleanupAllRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CleanupAllRequestDefaultTypeInternal _CleanupAllRequest_default_instance_;
PROTOBUF_CONSTEXPR CleanupAllResponse::CleanupAllResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CleanupAllResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CleanupAllResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CleanupAllResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CleanupAllResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CleanupAllResponseDefaultTypeInternal _CleanupAllResponse_default_instance_;
PROTOBUF_CONSTEXPR ExecutorOpts::ExecutorOpts(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.record_costs_)*/false
  , /*decltype(_impl_.record_timeline_)*/false
  , /*decltype(_impl_.record_partition_graphs_)*/false
  , /*decltype(_impl_.report_tensor_allocations_upon_oom_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ExecutorOptsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ExecutorOptsDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ExecutorOptsDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    ExecutorOpts _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExecutorOptsDefaultTypeInternal _ExecutorOpts_default_instance_;
PROTOBUF_CONSTEXPR RunGraphRequest::RunGraphRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.send_)*/{}
  , /*decltype(_impl_.recv_key_)*/{}
  , /*decltype(_impl_.graph_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.exec_opts_)*/nullptr
  , /*decltype(_impl_.step_id_)*/::int64_t{0}
  , /*decltype(_impl_.request_id_)*/::int64_t{0}
  , /*decltype(_impl_.create_worker_session_called_)*/false
  , /*decltype(_impl_.is_partial_)*/false
  , /*decltype(_impl_.is_last_partial_run_)*/false
  , /*decltype(_impl_.store_errors_in_response_body_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RunGraphRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RunGraphRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RunGraphRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RunGraphRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunGraphRequestDefaultTypeInternal _RunGraphRequest_default_instance_;
PROTOBUF_CONSTEXPR RunGraphResponse::RunGraphResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.recv_)*/{}
  , /*decltype(_impl_.partition_graph_)*/{}
  , /*decltype(_impl_.status_error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.step_stats_)*/nullptr
  , /*decltype(_impl_.cost_graph_)*/nullptr
  , /*decltype(_impl_.status_code_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RunGraphResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RunGraphResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RunGraphResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RunGraphResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunGraphResponseDefaultTypeInternal _RunGraphResponse_default_instance_;
PROTOBUF_CONSTEXPR CleanupGraphRequest::CleanupGraphRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.step_id_)*/::int64_t{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CleanupGraphRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CleanupGraphRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CleanupGraphRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CleanupGraphRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CleanupGraphRequestDefaultTypeInternal _CleanupGraphRequest_default_instance_;
PROTOBUF_CONSTEXPR CleanupGraphResponse::CleanupGraphResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CleanupGraphResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CleanupGraphResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CleanupGraphResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CleanupGraphResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CleanupGraphResponseDefaultTypeInternal _CleanupGraphResponse_default_instance_;
PROTOBUF_CONSTEXPR RecvTensorRequest::RecvTensorRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.rendezvous_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_locality_)*/nullptr
  , /*decltype(_impl_.server_locality_)*/nullptr
  , /*decltype(_impl_.transport_options_)*/nullptr
  , /*decltype(_impl_.step_id_)*/::int64_t{0}
  , /*decltype(_impl_.request_id_)*/::int64_t{0}
  , /*decltype(_impl_.dma_ok_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RecvTensorRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RecvTensorRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RecvTensorRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RecvTensorRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecvTensorRequestDefaultTypeInternal _RecvTensorRequest_default_instance_;
PROTOBUF_CONSTEXPR RecvTensorResponse::RecvTensorResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.tensor_)*/nullptr
  , /*decltype(_impl_.transport_options_)*/nullptr
  , /*decltype(_impl_.send_start_micros_)*/::int64_t{0}
  , /*decltype(_impl_.is_dead_)*/false
  , /*decltype(_impl_.require_ack_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RecvTensorResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RecvTensorResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RecvTensorResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RecvTensorResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecvTensorResponseDefaultTypeInternal _RecvTensorResponse_default_instance_;
PROTOBUF_CONSTEXPR MarkRecvFinishedRequest::MarkRecvFinishedRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.request_id_)*/::int64_t{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct MarkRecvFinishedRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MarkRecvFinishedRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MarkRecvFinishedRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    MarkRecvFinishedRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MarkRecvFinishedRequestDefaultTypeInternal _MarkRecvFinishedRequest_default_instance_;
PROTOBUF_CONSTEXPR MarkRecvFinishedResponse::MarkRecvFinishedResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct MarkRecvFinishedResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MarkRecvFinishedResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MarkRecvFinishedResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    MarkRecvFinishedResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MarkRecvFinishedResponseDefaultTypeInternal _MarkRecvFinishedResponse_default_instance_;
PROTOBUF_CONSTEXPR LoggingRequest::LoggingRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.fetch_step_id_)*/{}
  , /*decltype(_impl_._fetch_step_id_cached_byte_size_)*/{0}
  , /*decltype(_impl_.enable_rpc_logging_)*/false
  , /*decltype(_impl_.disable_rpc_logging_)*/false
  , /*decltype(_impl_.clear_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct LoggingRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR LoggingRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~LoggingRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    LoggingRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoggingRequestDefaultTypeInternal _LoggingRequest_default_instance_;
PROTOBUF_CONSTEXPR LabeledStepStats::LabeledStepStats(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.step_stats_)*/nullptr
  , /*decltype(_impl_.step_id_)*/::int64_t{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct LabeledStepStatsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR LabeledStepStatsDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~LabeledStepStatsDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    LabeledStepStats _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LabeledStepStatsDefaultTypeInternal _LabeledStepStats_default_instance_;
PROTOBUF_CONSTEXPR LoggingResponse::LoggingResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.step_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct LoggingResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR LoggingResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~LoggingResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    LoggingResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoggingResponseDefaultTypeInternal _LoggingResponse_default_instance_;
PROTOBUF_CONSTEXPR TraceOpts::TraceOpts(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.duration_)*/0
  , /*decltype(_impl_.use_step_profiler_)*/false
  , /*decltype(_impl_.use_kernel_profiler_)*/false
  , /*decltype(_impl_.use_extended_profiler_)*/false
  , /*decltype(_impl_.use_gpu_profiler_)*/false
  , /*decltype(_impl_.use_sample_profiler_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct TraceOptsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TraceOptsDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~TraceOptsDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    TraceOpts _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TraceOptsDefaultTypeInternal _TraceOpts_default_instance_;
PROTOBUF_CONSTEXPR TracingRequest::TracingRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.options_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct TracingRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TracingRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~TracingRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    TracingRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingRequestDefaultTypeInternal _TracingRequest_default_instance_;
PROTOBUF_CONSTEXPR TracingResponse::TracingResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct TracingResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TracingResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~TracingResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    TracingResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingResponseDefaultTypeInternal _TracingResponse_default_instance_;
PROTOBUF_CONSTEXPR RecvBufRequest::RecvBufRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.buf_rendezvous_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.src_device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.dst_device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_locality_)*/nullptr
  , /*decltype(_impl_.server_locality_)*/nullptr
  , /*decltype(_impl_.transport_options_)*/nullptr
  , /*decltype(_impl_.step_id_)*/::int64_t{0}
  , /*decltype(_impl_.num_bytes_)*/::int64_t{0}
  , /*decltype(_impl_.buf_ptr_)*/::uint64_t{0u}
  , /*decltype(_impl_.request_id_)*/::int64_t{0}
  , /*decltype(_impl_.src_incarnation_)*/::uint64_t{0u}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RecvBufRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RecvBufRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RecvBufRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RecvBufRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecvBufRequestDefaultTypeInternal _RecvBufRequest_default_instance_;
PROTOBUF_CONSTEXPR RecvBufResponse::RecvBufResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.transport_options_)*/nullptr
  , /*decltype(_impl_.buf_ptr_)*/::uint64_t{0u}
  , /*decltype(_impl_.num_bytes_)*/::int64_t{0}
  , /*decltype(_impl_.send_start_micros_)*/::int64_t{0}
  , /*decltype(_impl_.is_dead_)*/false
  , /*decltype(_impl_.require_ack_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct RecvBufResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RecvBufResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~RecvBufResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    RecvBufResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecvBufResponseDefaultTypeInternal _RecvBufResponse_default_instance_;
PROTOBUF_CONSTEXPR CompleteGroupRequest::CompleteGroupRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.device_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.device_attributes_)*/nullptr
  , /*decltype(_impl_.group_key_)*/0
  , /*decltype(_impl_.group_size_)*/0
  , /*decltype(_impl_.collective_type_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CompleteGroupRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CompleteGroupRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CompleteGroupRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CompleteGroupRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompleteGroupRequestDefaultTypeInternal _CompleteGroupRequest_default_instance_;
PROTOBUF_CONSTEXPR CompleteGroupResponse::CompleteGroupResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.device_attributes_)*/{}
  , /*decltype(_impl_.device_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.communicator_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.group_key_)*/0
  , /*decltype(_impl_.group_size_)*/0
  , /*decltype(_impl_.num_tasks_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CompleteGroupResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CompleteGroupResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CompleteGroupResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CompleteGroupResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompleteGroupResponseDefaultTypeInternal _CompleteGroupResponse_default_instance_;
PROTOBUF_CONSTEXPR CompleteInstanceRequest::CompleteInstanceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.subdiv_offset_)*/{}
  , /*decltype(_impl_._subdiv_offset_cached_byte_size_)*/{0}
  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.device_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.shape_)*/nullptr
  , /*decltype(_impl_.type_)*/0
  , /*decltype(_impl_.data_type_)*/0
  , /*decltype(_impl_.group_key_)*/0
  , /*decltype(_impl_.group_size_)*/0
  , /*decltype(_impl_.instance_key_)*/0
  , /*decltype(_impl_.is_source_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CompleteInstanceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CompleteInstanceRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CompleteInstanceRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CompleteInstanceRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompleteInstanceRequestDefaultTypeInternal _CompleteInstanceRequest_default_instance_;
PROTOBUF_CONSTEXPR CompleteInstanceResponse::CompleteInstanceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.instance_key_)*/0
  , /*decltype(_impl_.source_rank_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CompleteInstanceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CompleteInstanceResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CompleteInstanceResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    CompleteInstanceResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompleteInstanceResponseDefaultTypeInternal _CompleteInstanceResponse_default_instance_;
PROTOBUF_CONSTEXPR GetStepSequenceRequest::GetStepSequenceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.graph_key_)*/{}
  , /*decltype(_impl_._graph_key_cached_byte_size_)*/{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetStepSequenceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetStepSequenceRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetStepSequenceRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    GetStepSequenceRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetStepSequenceRequestDefaultTypeInternal _GetStepSequenceRequest_default_instance_;
PROTOBUF_CONSTEXPR StepSequence::StepSequence(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.graph_key_)*/::int64_t{0}
  , /*decltype(_impl_.next_step_id_)*/::int64_t{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct StepSequenceDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StepSequenceDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StepSequenceDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    StepSequence _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StepSequenceDefaultTypeInternal _StepSequence_default_instance_;
PROTOBUF_CONSTEXPR GetStepSequenceResponse::GetStepSequenceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.step_sequence_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetStepSequenceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetStepSequenceResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetStepSequenceResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    GetStepSequenceResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetStepSequenceResponseDefaultTypeInternal _GetStepSequenceResponse_default_instance_;
}  // namespace tensorflow
namespace tensorflow {

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

class GetStatusRequest::_Internal {
 public:
};

GetStatusRequest::GetStatusRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.GetStatusRequest)
}
GetStatusRequest::GetStatusRequest(const GetStatusRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetStatusRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.GetStatusRequest)
}

inline void GetStatusRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

GetStatusRequest::~GetStatusRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.GetStatusRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetStatusRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetStatusRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetStatusRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.GetStatusRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* GetStatusRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetStatusRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetStatusRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetStatusRequest)
  return target;
}

size_t GetStatusRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.GetStatusRequest)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetStatusRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetStatusRequest*>(
      &from));
}

void GetStatusRequest::MergeFrom(const GetStatusRequest& from) {
  GetStatusRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetStatusRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetStatusRequest::CopyFrom(const GetStatusRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetStatusRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetStatusRequest::IsInitialized() const {
  return true;
}

void GetStatusRequest::InternalSwap(GetStatusRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetStatusRequest::GetTypeName() const {
  return "tensorflow.GetStatusRequest";
}


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

class GetStatusResponse::_Internal {
 public:
};

void GetStatusResponse::clear_device_attributes() {
  _impl_.device_attributes_.Clear();
}
GetStatusResponse::GetStatusResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.GetStatusResponse)
}
GetStatusResponse::GetStatusResponse(const GetStatusResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetStatusResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.device_attributes_){from._impl_.device_attributes_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.GetStatusResponse)
}

inline void GetStatusResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.device_attributes_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

GetStatusResponse::~GetStatusResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.GetStatusResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetStatusResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.device_attributes_.~RepeatedPtrField();
}

void GetStatusResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetStatusResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.GetStatusResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.device_attributes_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetStatusResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .tensorflow.DeviceAttributes device_attributes = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_device_attributes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetStatusResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetStatusResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .tensorflow.DeviceAttributes device_attributes = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_device_attributes_size()); i < n; i++) {
    const auto& repfield = this->_internal_device_attributes(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetStatusResponse)
  return target;
}

size_t GetStatusResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.GetStatusResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.DeviceAttributes device_attributes = 1;
  total_size += 1UL * this->_internal_device_attributes_size();
  for (const auto& msg : this->_impl_.device_attributes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetStatusResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetStatusResponse*>(
      &from));
}

void GetStatusResponse::MergeFrom(const GetStatusResponse& from) {
  GetStatusResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetStatusResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.device_attributes_.MergeFrom(from._impl_.device_attributes_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetStatusResponse::CopyFrom(const GetStatusResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetStatusResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetStatusResponse::IsInitialized() const {
  return true;
}

void GetStatusResponse::InternalSwap(GetStatusResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.device_attributes_.InternalSwap(&other->_impl_.device_attributes_);
}

std::string GetStatusResponse::GetTypeName() const {
  return "tensorflow.GetStatusResponse";
}


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

class CreateWorkerSessionRequest::_Internal {
 public:
  static const ::tensorflow::ServerDef& server_def(const CreateWorkerSessionRequest* msg);
};

const ::tensorflow::ServerDef&
CreateWorkerSessionRequest::_Internal::server_def(const CreateWorkerSessionRequest* msg) {
  return *msg->_impl_.server_def_;
}
void CreateWorkerSessionRequest::clear_server_def() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_def_ != nullptr) {
    delete _impl_.server_def_;
  }
  _impl_.server_def_ = nullptr;
}
void CreateWorkerSessionRequest::clear_cluster_device_attributes() {
  _impl_.cluster_device_attributes_.Clear();
}
CreateWorkerSessionRequest::CreateWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CreateWorkerSessionRequest)
}
CreateWorkerSessionRequest::CreateWorkerSessionRequest(const CreateWorkerSessionRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CreateWorkerSessionRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.cluster_device_attributes_){from._impl_.cluster_device_attributes_}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.master_task_){}
    , decltype(_impl_.server_def_){nullptr}
    , decltype(_impl_.master_incarnation_){}
    , decltype(_impl_.isolate_session_state_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_session_handle().empty()) {
    _this->_impl_.session_handle_.Set(from._internal_session_handle(),
      _this->GetArenaForAllocation());
  }
  _impl_.master_task_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.master_task_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_master_task().empty()) {
    _this->_impl_.master_task_.Set(from._internal_master_task(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_server_def()) {
    _this->_impl_.server_def_ = new ::tensorflow::ServerDef(*from._impl_.server_def_);
  }
  ::memcpy(&_impl_.master_incarnation_, &from._impl_.master_incarnation_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.isolate_session_state_) -
    reinterpret_cast<char*>(&_impl_.master_incarnation_)) + sizeof(_impl_.isolate_session_state_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.CreateWorkerSessionRequest)
}

inline void CreateWorkerSessionRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.cluster_device_attributes_){arena}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.master_task_){}
    , decltype(_impl_.server_def_){nullptr}
    , decltype(_impl_.master_incarnation_){::int64_t{0}}
    , decltype(_impl_.isolate_session_state_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.master_task_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.master_task_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CreateWorkerSessionRequest::~CreateWorkerSessionRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.CreateWorkerSessionRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CreateWorkerSessionRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.cluster_device_attributes_.~RepeatedPtrField();
  _impl_.session_handle_.Destroy();
  _impl_.master_task_.Destroy();
  if (this != internal_default_instance()) delete _impl_.server_def_;
}

void CreateWorkerSessionRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CreateWorkerSessionRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CreateWorkerSessionRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.cluster_device_attributes_.Clear();
  _impl_.session_handle_.ClearToEmpty();
  _impl_.master_task_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.server_def_ != nullptr) {
    delete _impl_.server_def_;
  }
  _impl_.server_def_ = nullptr;
  ::memset(&_impl_.master_incarnation_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.isolate_session_state_) -
      reinterpret_cast<char*>(&_impl_.master_incarnation_)) + sizeof(_impl_.isolate_session_state_));
  _internal_metadata_.Clear<std::string>();
}

const char* CreateWorkerSessionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string session_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_session_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.ServerDef server_def = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_server_def(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool isolate_session_state = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.isolate_session_state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .tensorflow.DeviceAttributes cluster_device_attributes = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_cluster_device_attributes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string master_task = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          auto str = _internal_mutable_master_task();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 master_incarnation = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.master_incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CreateWorkerSessionRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CreateWorkerSessionRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CreateWorkerSessionRequest.session_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_session_handle(), target);
  }

  // .tensorflow.ServerDef server_def = 2;
  if (this->_internal_has_server_def()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::server_def(this),
        _Internal::server_def(this).GetCachedSize(), target, stream);
  }

  // bool isolate_session_state = 3;
  if (this->_internal_isolate_session_state() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_isolate_session_state(), target);
  }

  // repeated .tensorflow.DeviceAttributes cluster_device_attributes = 4;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_cluster_device_attributes_size()); i < n; i++) {
    const auto& repfield = this->_internal_cluster_device_attributes(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
  }

  // string master_task = 5;
  if (!this->_internal_master_task().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_master_task().data(), static_cast<int>(this->_internal_master_task().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CreateWorkerSessionRequest.master_task");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_master_task(), target);
  }

  // int64 master_incarnation = 6;
  if (this->_internal_master_incarnation() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_master_incarnation(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CreateWorkerSessionRequest)
  return target;
}

size_t CreateWorkerSessionRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CreateWorkerSessionRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.DeviceAttributes cluster_device_attributes = 4;
  total_size += 1UL * this->_internal_cluster_device_attributes_size();
  for (const auto& msg : this->_impl_.cluster_device_attributes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_session_handle());
  }

  // string master_task = 5;
  if (!this->_internal_master_task().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_master_task());
  }

  // .tensorflow.ServerDef server_def = 2;
  if (this->_internal_has_server_def()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.server_def_);
  }

  // int64 master_incarnation = 6;
  if (this->_internal_master_incarnation() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_master_incarnation());
  }

  // bool isolate_session_state = 3;
  if (this->_internal_isolate_session_state() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CreateWorkerSessionRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CreateWorkerSessionRequest*>(
      &from));
}

void CreateWorkerSessionRequest::MergeFrom(const CreateWorkerSessionRequest& from) {
  CreateWorkerSessionRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CreateWorkerSessionRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.cluster_device_attributes_.MergeFrom(from._impl_.cluster_device_attributes_);
  if (!from._internal_session_handle().empty()) {
    _this->_internal_set_session_handle(from._internal_session_handle());
  }
  if (!from._internal_master_task().empty()) {
    _this->_internal_set_master_task(from._internal_master_task());
  }
  if (from._internal_has_server_def()) {
    _this->_internal_mutable_server_def()->::tensorflow::ServerDef::MergeFrom(
        from._internal_server_def());
  }
  if (from._internal_master_incarnation() != 0) {
    _this->_internal_set_master_incarnation(from._internal_master_incarnation());
  }
  if (from._internal_isolate_session_state() != 0) {
    _this->_internal_set_isolate_session_state(from._internal_isolate_session_state());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CreateWorkerSessionRequest::CopyFrom(const CreateWorkerSessionRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CreateWorkerSessionRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CreateWorkerSessionRequest::IsInitialized() const {
  return true;
}

void CreateWorkerSessionRequest::InternalSwap(CreateWorkerSessionRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.cluster_device_attributes_.InternalSwap(&other->_impl_.cluster_device_attributes_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.session_handle_, lhs_arena,
      &other->_impl_.session_handle_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.master_task_, lhs_arena,
      &other->_impl_.master_task_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CreateWorkerSessionRequest, _impl_.isolate_session_state_)
      + sizeof(CreateWorkerSessionRequest::_impl_.isolate_session_state_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(CreateWorkerSessionRequest, _impl_.server_def_)>(
          reinterpret_cast<char*>(&_impl_.server_def_),
          reinterpret_cast<char*>(&other->_impl_.server_def_));
}

std::string CreateWorkerSessionRequest::GetTypeName() const {
  return "tensorflow.CreateWorkerSessionRequest";
}


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

class CreateWorkerSessionResponse::_Internal {
 public:
};

CreateWorkerSessionResponse::CreateWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CreateWorkerSessionResponse)
}
CreateWorkerSessionResponse::CreateWorkerSessionResponse(const CreateWorkerSessionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CreateWorkerSessionResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.CreateWorkerSessionResponse)
}

inline void CreateWorkerSessionResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

CreateWorkerSessionResponse::~CreateWorkerSessionResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.CreateWorkerSessionResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CreateWorkerSessionResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CreateWorkerSessionResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CreateWorkerSessionResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CreateWorkerSessionResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* CreateWorkerSessionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CreateWorkerSessionResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CreateWorkerSessionResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CreateWorkerSessionResponse)
  return target;
}

size_t CreateWorkerSessionResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CreateWorkerSessionResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CreateWorkerSessionResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CreateWorkerSessionResponse*>(
      &from));
}

void CreateWorkerSessionResponse::MergeFrom(const CreateWorkerSessionResponse& from) {
  CreateWorkerSessionResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CreateWorkerSessionResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CreateWorkerSessionResponse::CopyFrom(const CreateWorkerSessionResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CreateWorkerSessionResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CreateWorkerSessionResponse::IsInitialized() const {
  return true;
}

void CreateWorkerSessionResponse::InternalSwap(CreateWorkerSessionResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string CreateWorkerSessionResponse::GetTypeName() const {
  return "tensorflow.CreateWorkerSessionResponse";
}


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

class DeleteWorkerSessionRequest::_Internal {
 public:
};

DeleteWorkerSessionRequest::DeleteWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.DeleteWorkerSessionRequest)
}
DeleteWorkerSessionRequest::DeleteWorkerSessionRequest(const DeleteWorkerSessionRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteWorkerSessionRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.session_handle_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_session_handle().empty()) {
    _this->_impl_.session_handle_.Set(from._internal_session_handle(),
      _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:tensorflow.DeleteWorkerSessionRequest)
}

inline void DeleteWorkerSessionRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.session_handle_){}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

DeleteWorkerSessionRequest::~DeleteWorkerSessionRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.DeleteWorkerSessionRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeleteWorkerSessionRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.session_handle_.Destroy();
}

void DeleteWorkerSessionRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeleteWorkerSessionRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.DeleteWorkerSessionRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.session_handle_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* DeleteWorkerSessionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string session_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_session_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeleteWorkerSessionRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeleteWorkerSessionRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.DeleteWorkerSessionRequest.session_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_session_handle(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeleteWorkerSessionRequest)
  return target;
}

size_t DeleteWorkerSessionRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.DeleteWorkerSessionRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_session_handle());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeleteWorkerSessionRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteWorkerSessionRequest*>(
      &from));
}

void DeleteWorkerSessionRequest::MergeFrom(const DeleteWorkerSessionRequest& from) {
  DeleteWorkerSessionRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeleteWorkerSessionRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_session_handle().empty()) {
    _this->_internal_set_session_handle(from._internal_session_handle());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteWorkerSessionRequest::CopyFrom(const DeleteWorkerSessionRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeleteWorkerSessionRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteWorkerSessionRequest::IsInitialized() const {
  return true;
}

void DeleteWorkerSessionRequest::InternalSwap(DeleteWorkerSessionRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.session_handle_, lhs_arena,
      &other->_impl_.session_handle_, rhs_arena
  );
}

std::string DeleteWorkerSessionRequest::GetTypeName() const {
  return "tensorflow.DeleteWorkerSessionRequest";
}


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

class DeleteWorkerSessionResponse::_Internal {
 public:
};

DeleteWorkerSessionResponse::DeleteWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.DeleteWorkerSessionResponse)
}
DeleteWorkerSessionResponse::DeleteWorkerSessionResponse(const DeleteWorkerSessionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteWorkerSessionResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.DeleteWorkerSessionResponse)
}

inline void DeleteWorkerSessionResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

DeleteWorkerSessionResponse::~DeleteWorkerSessionResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.DeleteWorkerSessionResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeleteWorkerSessionResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void DeleteWorkerSessionResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeleteWorkerSessionResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.DeleteWorkerSessionResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* DeleteWorkerSessionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeleteWorkerSessionResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeleteWorkerSessionResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeleteWorkerSessionResponse)
  return target;
}

size_t DeleteWorkerSessionResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.DeleteWorkerSessionResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeleteWorkerSessionResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteWorkerSessionResponse*>(
      &from));
}

void DeleteWorkerSessionResponse::MergeFrom(const DeleteWorkerSessionResponse& from) {
  DeleteWorkerSessionResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeleteWorkerSessionResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteWorkerSessionResponse::CopyFrom(const DeleteWorkerSessionResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeleteWorkerSessionResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteWorkerSessionResponse::IsInitialized() const {
  return true;
}

void DeleteWorkerSessionResponse::InternalSwap(DeleteWorkerSessionResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string DeleteWorkerSessionResponse::GetTypeName() const {
  return "tensorflow.DeleteWorkerSessionResponse";
}


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

class RegisterGraphRequest::_Internal {
 public:
  static const ::tensorflow::GraphDef& graph_def(const RegisterGraphRequest* msg);
  static const ::tensorflow::GraphOptions& graph_options(const RegisterGraphRequest* msg);
  static const ::tensorflow::DebugOptions& debug_options(const RegisterGraphRequest* msg);
  static const ::tensorflow::ConfigProto& config_proto(const RegisterGraphRequest* msg);
};

const ::tensorflow::GraphDef&
RegisterGraphRequest::_Internal::graph_def(const RegisterGraphRequest* msg) {
  return *msg->_impl_.graph_def_;
}
const ::tensorflow::GraphOptions&
RegisterGraphRequest::_Internal::graph_options(const RegisterGraphRequest* msg) {
  return *msg->_impl_.graph_options_;
}
const ::tensorflow::DebugOptions&
RegisterGraphRequest::_Internal::debug_options(const RegisterGraphRequest* msg) {
  return *msg->_impl_.debug_options_;
}
const ::tensorflow::ConfigProto&
RegisterGraphRequest::_Internal::config_proto(const RegisterGraphRequest* msg) {
  return *msg->_impl_.config_proto_;
}
void RegisterGraphRequest::clear_graph_def() {
  if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
    delete _impl_.graph_def_;
  }
  _impl_.graph_def_ = nullptr;
}
void RegisterGraphRequest::clear_graph_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.graph_options_ != nullptr) {
    delete _impl_.graph_options_;
  }
  _impl_.graph_options_ = nullptr;
}
void RegisterGraphRequest::clear_debug_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.debug_options_ != nullptr) {
    delete _impl_.debug_options_;
  }
  _impl_.debug_options_ = nullptr;
}
void RegisterGraphRequest::clear_config_proto() {
  if (GetArenaForAllocation() == nullptr && _impl_.config_proto_ != nullptr) {
    delete _impl_.config_proto_;
  }
  _impl_.config_proto_ = nullptr;
}
RegisterGraphRequest::RegisterGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RegisterGraphRequest)
}
RegisterGraphRequest::RegisterGraphRequest(const RegisterGraphRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RegisterGraphRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.session_handle_){}
    , decltype(_impl_.graph_def_){nullptr}
    , decltype(_impl_.graph_options_){nullptr}
    , decltype(_impl_.debug_options_){nullptr}
    , decltype(_impl_.config_proto_){nullptr}
    , decltype(_impl_.collective_graph_key_){}
    , decltype(_impl_.create_worker_session_called_){}
    , decltype(_impl_.has_control_flow_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_session_handle().empty()) {
    _this->_impl_.session_handle_.Set(from._internal_session_handle(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_graph_def()) {
    _this->_impl_.graph_def_ = new ::tensorflow::GraphDef(*from._impl_.graph_def_);
  }
  if (from._internal_has_graph_options()) {
    _this->_impl_.graph_options_ = new ::tensorflow::GraphOptions(*from._impl_.graph_options_);
  }
  if (from._internal_has_debug_options()) {
    _this->_impl_.debug_options_ = new ::tensorflow::DebugOptions(*from._impl_.debug_options_);
  }
  if (from._internal_has_config_proto()) {
    _this->_impl_.config_proto_ = new ::tensorflow::ConfigProto(*from._impl_.config_proto_);
  }
  ::memcpy(&_impl_.collective_graph_key_, &from._impl_.collective_graph_key_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.has_control_flow_) -
    reinterpret_cast<char*>(&_impl_.collective_graph_key_)) + sizeof(_impl_.has_control_flow_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RegisterGraphRequest)
}

inline void RegisterGraphRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.session_handle_){}
    , decltype(_impl_.graph_def_){nullptr}
    , decltype(_impl_.graph_options_){nullptr}
    , decltype(_impl_.debug_options_){nullptr}
    , decltype(_impl_.config_proto_){nullptr}
    , decltype(_impl_.collective_graph_key_){::int64_t{0}}
    , decltype(_impl_.create_worker_session_called_){false}
    , decltype(_impl_.has_control_flow_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RegisterGraphRequest::~RegisterGraphRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.RegisterGraphRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RegisterGraphRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.session_handle_.Destroy();
  if (this != internal_default_instance()) delete _impl_.graph_def_;
  if (this != internal_default_instance()) delete _impl_.graph_options_;
  if (this != internal_default_instance()) delete _impl_.debug_options_;
  if (this != internal_default_instance()) delete _impl_.config_proto_;
}

void RegisterGraphRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RegisterGraphRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RegisterGraphRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.session_handle_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
    delete _impl_.graph_def_;
  }
  _impl_.graph_def_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.graph_options_ != nullptr) {
    delete _impl_.graph_options_;
  }
  _impl_.graph_options_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.debug_options_ != nullptr) {
    delete _impl_.debug_options_;
  }
  _impl_.debug_options_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.config_proto_ != nullptr) {
    delete _impl_.config_proto_;
  }
  _impl_.config_proto_ = nullptr;
  ::memset(&_impl_.collective_graph_key_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.has_control_flow_) -
      reinterpret_cast<char*>(&_impl_.collective_graph_key_)) + sizeof(_impl_.has_control_flow_));
  _internal_metadata_.Clear<std::string>();
}

const char* RegisterGraphRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string session_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_session_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.GraphDef graph_def = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_graph_def(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool has_control_flow = 3 [deprecated = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.has_control_flow_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.GraphOptions graph_options = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_graph_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DebugOptions debug_options = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_debug_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool create_worker_session_called = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.create_worker_session_called_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 collective_graph_key = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          _impl_.collective_graph_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.ConfigProto config_proto = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_config_proto(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RegisterGraphRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RegisterGraphRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RegisterGraphRequest.session_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_session_handle(), target);
  }

  // .tensorflow.GraphDef graph_def = 2;
  if (this->_internal_has_graph_def()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::graph_def(this),
        _Internal::graph_def(this).GetCachedSize(), target, stream);
  }

  // bool has_control_flow = 3 [deprecated = true];
  if (this->_internal_has_control_flow() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_has_control_flow(), target);
  }

  // .tensorflow.GraphOptions graph_options = 4;
  if (this->_internal_has_graph_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::graph_options(this),
        _Internal::graph_options(this).GetCachedSize(), target, stream);
  }

  // .tensorflow.DebugOptions debug_options = 5;
  if (this->_internal_has_debug_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::debug_options(this),
        _Internal::debug_options(this).GetCachedSize(), target, stream);
  }

  // bool create_worker_session_called = 6;
  if (this->_internal_create_worker_session_called() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_create_worker_session_called(), target);
  }

  // int64 collective_graph_key = 7;
  if (this->_internal_collective_graph_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_collective_graph_key(), target);
  }

  // .tensorflow.ConfigProto config_proto = 8;
  if (this->_internal_has_config_proto()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, _Internal::config_proto(this),
        _Internal::config_proto(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RegisterGraphRequest)
  return target;
}

size_t RegisterGraphRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RegisterGraphRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string session_handle = 1;
  if (!this->_internal_session_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_session_handle());
  }

  // .tensorflow.GraphDef graph_def = 2;
  if (this->_internal_has_graph_def()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.graph_def_);
  }

  // .tensorflow.GraphOptions graph_options = 4;
  if (this->_internal_has_graph_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.graph_options_);
  }

  // .tensorflow.DebugOptions debug_options = 5;
  if (this->_internal_has_debug_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.debug_options_);
  }

  // .tensorflow.ConfigProto config_proto = 8;
  if (this->_internal_has_config_proto()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.config_proto_);
  }

  // int64 collective_graph_key = 7;
  if (this->_internal_collective_graph_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_collective_graph_key());
  }

  // bool create_worker_session_called = 6;
  if (this->_internal_create_worker_session_called() != 0) {
    total_size += 1 + 1;
  }

  // bool has_control_flow = 3 [deprecated = true];
  if (this->_internal_has_control_flow() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RegisterGraphRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RegisterGraphRequest*>(
      &from));
}

void RegisterGraphRequest::MergeFrom(const RegisterGraphRequest& from) {
  RegisterGraphRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RegisterGraphRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_session_handle().empty()) {
    _this->_internal_set_session_handle(from._internal_session_handle());
  }
  if (from._internal_has_graph_def()) {
    _this->_internal_mutable_graph_def()->::tensorflow::GraphDef::MergeFrom(
        from._internal_graph_def());
  }
  if (from._internal_has_graph_options()) {
    _this->_internal_mutable_graph_options()->::tensorflow::GraphOptions::MergeFrom(
        from._internal_graph_options());
  }
  if (from._internal_has_debug_options()) {
    _this->_internal_mutable_debug_options()->::tensorflow::DebugOptions::MergeFrom(
        from._internal_debug_options());
  }
  if (from._internal_has_config_proto()) {
    _this->_internal_mutable_config_proto()->::tensorflow::ConfigProto::MergeFrom(
        from._internal_config_proto());
  }
  if (from._internal_collective_graph_key() != 0) {
    _this->_internal_set_collective_graph_key(from._internal_collective_graph_key());
  }
  if (from._internal_create_worker_session_called() != 0) {
    _this->_internal_set_create_worker_session_called(from._internal_create_worker_session_called());
  }
  if (from._internal_has_control_flow() != 0) {
    _this->_internal_set_has_control_flow(from._internal_has_control_flow());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RegisterGraphRequest::CopyFrom(const RegisterGraphRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RegisterGraphRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RegisterGraphRequest::IsInitialized() const {
  return true;
}

void RegisterGraphRequest::InternalSwap(RegisterGraphRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.session_handle_, lhs_arena,
      &other->_impl_.session_handle_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RegisterGraphRequest, _impl_.has_control_flow_)
      + sizeof(RegisterGraphRequest::_impl_.has_control_flow_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RegisterGraphRequest, _impl_.graph_def_)>(
          reinterpret_cast<char*>(&_impl_.graph_def_),
          reinterpret_cast<char*>(&other->_impl_.graph_def_));
}

std::string RegisterGraphRequest::GetTypeName() const {
  return "tensorflow.RegisterGraphRequest";
}


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

class RegisterGraphResponse::_Internal {
 public:
};

RegisterGraphResponse::RegisterGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RegisterGraphResponse)
}
RegisterGraphResponse::RegisterGraphResponse(const RegisterGraphResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RegisterGraphResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_handle_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_graph_handle().empty()) {
    _this->_impl_.graph_handle_.Set(from._internal_graph_handle(),
      _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:tensorflow.RegisterGraphResponse)
}

inline void RegisterGraphResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_handle_){}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RegisterGraphResponse::~RegisterGraphResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.RegisterGraphResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RegisterGraphResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.graph_handle_.Destroy();
}

void RegisterGraphResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RegisterGraphResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RegisterGraphResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.graph_handle_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* RegisterGraphResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string graph_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_graph_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RegisterGraphResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RegisterGraphResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_graph_handle().data(), static_cast<int>(this->_internal_graph_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RegisterGraphResponse.graph_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_graph_handle(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RegisterGraphResponse)
  return target;
}

size_t RegisterGraphResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RegisterGraphResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_graph_handle());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RegisterGraphResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RegisterGraphResponse*>(
      &from));
}

void RegisterGraphResponse::MergeFrom(const RegisterGraphResponse& from) {
  RegisterGraphResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RegisterGraphResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_graph_handle().empty()) {
    _this->_internal_set_graph_handle(from._internal_graph_handle());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RegisterGraphResponse::CopyFrom(const RegisterGraphResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RegisterGraphResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RegisterGraphResponse::IsInitialized() const {
  return true;
}

void RegisterGraphResponse::InternalSwap(RegisterGraphResponse* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.graph_handle_, lhs_arena,
      &other->_impl_.graph_handle_, rhs_arena
  );
}

std::string RegisterGraphResponse::GetTypeName() const {
  return "tensorflow.RegisterGraphResponse";
}


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

class DeregisterGraphRequest::_Internal {
 public:
};

DeregisterGraphRequest::DeregisterGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.DeregisterGraphRequest)
}
DeregisterGraphRequest::DeregisterGraphRequest(const DeregisterGraphRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeregisterGraphRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_handle_){}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.create_worker_session_called_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_graph_handle().empty()) {
    _this->_impl_.graph_handle_.Set(from._internal_graph_handle(),
      _this->GetArenaForAllocation());
  }
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_session_handle().empty()) {
    _this->_impl_.session_handle_.Set(from._internal_session_handle(),
      _this->GetArenaForAllocation());
  }
  _this->_impl_.create_worker_session_called_ = from._impl_.create_worker_session_called_;
  // @@protoc_insertion_point(copy_constructor:tensorflow.DeregisterGraphRequest)
}

inline void DeregisterGraphRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_handle_){}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.create_worker_session_called_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

DeregisterGraphRequest::~DeregisterGraphRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.DeregisterGraphRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeregisterGraphRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.graph_handle_.Destroy();
  _impl_.session_handle_.Destroy();
}

void DeregisterGraphRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeregisterGraphRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.DeregisterGraphRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.graph_handle_.ClearToEmpty();
  _impl_.session_handle_.ClearToEmpty();
  _impl_.create_worker_session_called_ = false;
  _internal_metadata_.Clear<std::string>();
}

const char* DeregisterGraphRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string graph_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_graph_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string session_handle = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_session_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // bool create_worker_session_called = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.create_worker_session_called_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeregisterGraphRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeregisterGraphRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_graph_handle().data(), static_cast<int>(this->_internal_graph_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.DeregisterGraphRequest.graph_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_graph_handle(), target);
  }

  // string session_handle = 2;
  if (!this->_internal_session_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.DeregisterGraphRequest.session_handle");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_session_handle(), target);
  }

  // bool create_worker_session_called = 3;
  if (this->_internal_create_worker_session_called() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_create_worker_session_called(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeregisterGraphRequest)
  return target;
}

size_t DeregisterGraphRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.DeregisterGraphRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_graph_handle());
  }

  // string session_handle = 2;
  if (!this->_internal_session_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_session_handle());
  }

  // bool create_worker_session_called = 3;
  if (this->_internal_create_worker_session_called() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeregisterGraphRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeregisterGraphRequest*>(
      &from));
}

void DeregisterGraphRequest::MergeFrom(const DeregisterGraphRequest& from) {
  DeregisterGraphRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeregisterGraphRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_graph_handle().empty()) {
    _this->_internal_set_graph_handle(from._internal_graph_handle());
  }
  if (!from._internal_session_handle().empty()) {
    _this->_internal_set_session_handle(from._internal_session_handle());
  }
  if (from._internal_create_worker_session_called() != 0) {
    _this->_internal_set_create_worker_session_called(from._internal_create_worker_session_called());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeregisterGraphRequest::CopyFrom(const DeregisterGraphRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeregisterGraphRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeregisterGraphRequest::IsInitialized() const {
  return true;
}

void DeregisterGraphRequest::InternalSwap(DeregisterGraphRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.graph_handle_, lhs_arena,
      &other->_impl_.graph_handle_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.session_handle_, lhs_arena,
      &other->_impl_.session_handle_, rhs_arena
  );
  swap(_impl_.create_worker_session_called_, other->_impl_.create_worker_session_called_);
}

std::string DeregisterGraphRequest::GetTypeName() const {
  return "tensorflow.DeregisterGraphRequest";
}


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

class DeregisterGraphResponse::_Internal {
 public:
};

DeregisterGraphResponse::DeregisterGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.DeregisterGraphResponse)
}
DeregisterGraphResponse::DeregisterGraphResponse(const DeregisterGraphResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeregisterGraphResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.DeregisterGraphResponse)
}

inline void DeregisterGraphResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

DeregisterGraphResponse::~DeregisterGraphResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.DeregisterGraphResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeregisterGraphResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void DeregisterGraphResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeregisterGraphResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.DeregisterGraphResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* DeregisterGraphResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeregisterGraphResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeregisterGraphResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeregisterGraphResponse)
  return target;
}

size_t DeregisterGraphResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.DeregisterGraphResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeregisterGraphResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeregisterGraphResponse*>(
      &from));
}

void DeregisterGraphResponse::MergeFrom(const DeregisterGraphResponse& from) {
  DeregisterGraphResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeregisterGraphResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeregisterGraphResponse::CopyFrom(const DeregisterGraphResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeregisterGraphResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeregisterGraphResponse::IsInitialized() const {
  return true;
}

void DeregisterGraphResponse::InternalSwap(DeregisterGraphResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string DeregisterGraphResponse::GetTypeName() const {
  return "tensorflow.DeregisterGraphResponse";
}


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

class CleanupAllRequest::_Internal {
 public:
};

CleanupAllRequest::CleanupAllRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CleanupAllRequest)
}
CleanupAllRequest::CleanupAllRequest(const CleanupAllRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CleanupAllRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.container_){from._impl_.container_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.CleanupAllRequest)
}

inline void CleanupAllRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.container_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CleanupAllRequest::~CleanupAllRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.CleanupAllRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CleanupAllRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.container_.~RepeatedPtrField();
}

void CleanupAllRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CleanupAllRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CleanupAllRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.container_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* CleanupAllRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated string container = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_container();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CleanupAllRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CleanupAllRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string container = 1;
  for (int i = 0, n = this->_internal_container_size(); i < n; i++) {
    const auto& s = this->_internal_container(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CleanupAllRequest.container");
    target = stream->WriteString(1, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CleanupAllRequest)
  return target;
}

size_t CleanupAllRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CleanupAllRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string container = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.container_.size());
  for (int i = 0, n = _impl_.container_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      _impl_.container_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CleanupAllRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CleanupAllRequest*>(
      &from));
}

void CleanupAllRequest::MergeFrom(const CleanupAllRequest& from) {
  CleanupAllRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CleanupAllRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.container_.MergeFrom(from._impl_.container_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CleanupAllRequest::CopyFrom(const CleanupAllRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CleanupAllRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CleanupAllRequest::IsInitialized() const {
  return true;
}

void CleanupAllRequest::InternalSwap(CleanupAllRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.container_.InternalSwap(&other->_impl_.container_);
}

std::string CleanupAllRequest::GetTypeName() const {
  return "tensorflow.CleanupAllRequest";
}


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

class CleanupAllResponse::_Internal {
 public:
};

CleanupAllResponse::CleanupAllResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CleanupAllResponse)
}
CleanupAllResponse::CleanupAllResponse(const CleanupAllResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CleanupAllResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.CleanupAllResponse)
}

inline void CleanupAllResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

CleanupAllResponse::~CleanupAllResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.CleanupAllResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CleanupAllResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CleanupAllResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CleanupAllResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CleanupAllResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* CleanupAllResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CleanupAllResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CleanupAllResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CleanupAllResponse)
  return target;
}

size_t CleanupAllResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CleanupAllResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CleanupAllResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CleanupAllResponse*>(
      &from));
}

void CleanupAllResponse::MergeFrom(const CleanupAllResponse& from) {
  CleanupAllResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CleanupAllResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CleanupAllResponse::CopyFrom(const CleanupAllResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CleanupAllResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CleanupAllResponse::IsInitialized() const {
  return true;
}

void CleanupAllResponse::InternalSwap(CleanupAllResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string CleanupAllResponse::GetTypeName() const {
  return "tensorflow.CleanupAllResponse";
}


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

class ExecutorOpts::_Internal {
 public:
};

ExecutorOpts::ExecutorOpts(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.ExecutorOpts)
}
ExecutorOpts::ExecutorOpts(const ExecutorOpts& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  ExecutorOpts* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.record_costs_){}
    , decltype(_impl_.record_timeline_){}
    , decltype(_impl_.record_partition_graphs_){}
    , decltype(_impl_.report_tensor_allocations_upon_oom_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.record_costs_, &from._impl_.record_costs_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.report_tensor_allocations_upon_oom_) -
    reinterpret_cast<char*>(&_impl_.record_costs_)) + sizeof(_impl_.report_tensor_allocations_upon_oom_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.ExecutorOpts)
}

inline void ExecutorOpts::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.record_costs_){false}
    , decltype(_impl_.record_timeline_){false}
    , decltype(_impl_.record_partition_graphs_){false}
    , decltype(_impl_.report_tensor_allocations_upon_oom_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ExecutorOpts::~ExecutorOpts() {
  // @@protoc_insertion_point(destructor:tensorflow.ExecutorOpts)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ExecutorOpts::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void ExecutorOpts::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void ExecutorOpts::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.ExecutorOpts)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.record_costs_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.report_tensor_allocations_upon_oom_) -
      reinterpret_cast<char*>(&_impl_.record_costs_)) + sizeof(_impl_.report_tensor_allocations_upon_oom_));
  _internal_metadata_.Clear<std::string>();
}

const char* ExecutorOpts::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool record_costs = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.record_costs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool record_timeline = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.record_timeline_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool record_partition_graphs = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.record_partition_graphs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool report_tensor_allocations_upon_oom = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.report_tensor_allocations_upon_oom_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* ExecutorOpts::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ExecutorOpts)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool record_costs = 1;
  if (this->_internal_record_costs() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_record_costs(), target);
  }

  // bool record_timeline = 3;
  if (this->_internal_record_timeline() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_record_timeline(), target);
  }

  // bool record_partition_graphs = 4;
  if (this->_internal_record_partition_graphs() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_record_partition_graphs(), target);
  }

  // bool report_tensor_allocations_upon_oom = 5;
  if (this->_internal_report_tensor_allocations_upon_oom() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_report_tensor_allocations_upon_oom(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ExecutorOpts)
  return target;
}

size_t ExecutorOpts::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.ExecutorOpts)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bool record_costs = 1;
  if (this->_internal_record_costs() != 0) {
    total_size += 1 + 1;
  }

  // bool record_timeline = 3;
  if (this->_internal_record_timeline() != 0) {
    total_size += 1 + 1;
  }

  // bool record_partition_graphs = 4;
  if (this->_internal_record_partition_graphs() != 0) {
    total_size += 1 + 1;
  }

  // bool report_tensor_allocations_upon_oom = 5;
  if (this->_internal_report_tensor_allocations_upon_oom() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ExecutorOpts::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ExecutorOpts*>(
      &from));
}

void ExecutorOpts::MergeFrom(const ExecutorOpts& from) {
  ExecutorOpts* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ExecutorOpts)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_record_costs() != 0) {
    _this->_internal_set_record_costs(from._internal_record_costs());
  }
  if (from._internal_record_timeline() != 0) {
    _this->_internal_set_record_timeline(from._internal_record_timeline());
  }
  if (from._internal_record_partition_graphs() != 0) {
    _this->_internal_set_record_partition_graphs(from._internal_record_partition_graphs());
  }
  if (from._internal_report_tensor_allocations_upon_oom() != 0) {
    _this->_internal_set_report_tensor_allocations_upon_oom(from._internal_report_tensor_allocations_upon_oom());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void ExecutorOpts::CopyFrom(const ExecutorOpts& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ExecutorOpts)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExecutorOpts::IsInitialized() const {
  return true;
}

void ExecutorOpts::InternalSwap(ExecutorOpts* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ExecutorOpts, _impl_.report_tensor_allocations_upon_oom_)
      + sizeof(ExecutorOpts::_impl_.report_tensor_allocations_upon_oom_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(ExecutorOpts, _impl_.record_costs_)>(
          reinterpret_cast<char*>(&_impl_.record_costs_),
          reinterpret_cast<char*>(&other->_impl_.record_costs_));
}

std::string ExecutorOpts::GetTypeName() const {
  return "tensorflow.ExecutorOpts";
}


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

class RunGraphRequest::_Internal {
 public:
  static const ::tensorflow::ExecutorOpts& exec_opts(const RunGraphRequest* msg);
};

const ::tensorflow::ExecutorOpts&
RunGraphRequest::_Internal::exec_opts(const RunGraphRequest* msg) {
  return *msg->_impl_.exec_opts_;
}
void RunGraphRequest::clear_send() {
  _impl_.send_.Clear();
}
RunGraphRequest::RunGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RunGraphRequest)
}
RunGraphRequest::RunGraphRequest(const RunGraphRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RunGraphRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.send_){from._impl_.send_}
    , decltype(_impl_.recv_key_){from._impl_.recv_key_}
    , decltype(_impl_.graph_handle_){}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.exec_opts_){nullptr}
    , decltype(_impl_.step_id_){}
    , decltype(_impl_.request_id_){}
    , decltype(_impl_.create_worker_session_called_){}
    , decltype(_impl_.is_partial_){}
    , decltype(_impl_.is_last_partial_run_){}
    , decltype(_impl_.store_errors_in_response_body_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_graph_handle().empty()) {
    _this->_impl_.graph_handle_.Set(from._internal_graph_handle(),
      _this->GetArenaForAllocation());
  }
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_session_handle().empty()) {
    _this->_impl_.session_handle_.Set(from._internal_session_handle(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_exec_opts()) {
    _this->_impl_.exec_opts_ = new ::tensorflow::ExecutorOpts(*from._impl_.exec_opts_);
  }
  ::memcpy(&_impl_.step_id_, &from._impl_.step_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.store_errors_in_response_body_) -
    reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.store_errors_in_response_body_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RunGraphRequest)
}

inline void RunGraphRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.send_){arena}
    , decltype(_impl_.recv_key_){arena}
    , decltype(_impl_.graph_handle_){}
    , decltype(_impl_.session_handle_){}
    , decltype(_impl_.exec_opts_){nullptr}
    , decltype(_impl_.step_id_){::int64_t{0}}
    , decltype(_impl_.request_id_){::int64_t{0}}
    , decltype(_impl_.create_worker_session_called_){false}
    , decltype(_impl_.is_partial_){false}
    , decltype(_impl_.is_last_partial_run_){false}
    , decltype(_impl_.store_errors_in_response_body_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.graph_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.graph_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.session_handle_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.session_handle_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RunGraphRequest::~RunGraphRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.RunGraphRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RunGraphRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.send_.~RepeatedPtrField();
  _impl_.recv_key_.~RepeatedPtrField();
  _impl_.graph_handle_.Destroy();
  _impl_.session_handle_.Destroy();
  if (this != internal_default_instance()) delete _impl_.exec_opts_;
}

void RunGraphRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RunGraphRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RunGraphRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.send_.Clear();
  _impl_.recv_key_.Clear();
  _impl_.graph_handle_.ClearToEmpty();
  _impl_.session_handle_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.exec_opts_ != nullptr) {
    delete _impl_.exec_opts_;
  }
  _impl_.exec_opts_ = nullptr;
  ::memset(&_impl_.step_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.store_errors_in_response_body_) -
      reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.store_errors_in_response_body_));
  _internal_metadata_.Clear<std::string>();
}

const char* RunGraphRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string graph_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_graph_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 step_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .tensorflow.NamedTensorProto send = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_send(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string recv_key = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_recv_key();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.ExecutorOpts exec_opts = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_exec_opts(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_partial = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.is_partial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_last_partial_run = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          _impl_.is_last_partial_run_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string session_handle = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          auto str = _internal_mutable_session_handle();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // bool store_errors_in_response_body = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
          _impl_.store_errors_in_response_body_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool create_worker_session_called = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
          _impl_.create_worker_session_called_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 request_id = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
          _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RunGraphRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunGraphRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_graph_handle().data(), static_cast<int>(this->_internal_graph_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RunGraphRequest.graph_handle");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_graph_handle(), target);
  }

  // int64 step_id = 2;
  if (this->_internal_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_step_id(), target);
  }

  // repeated .tensorflow.NamedTensorProto send = 3;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_send_size()); i < n; i++) {
    const auto& repfield = this->_internal_send(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
  }

  // repeated string recv_key = 4;
  for (int i = 0, n = this->_internal_recv_key_size(); i < n; i++) {
    const auto& s = this->_internal_recv_key(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RunGraphRequest.recv_key");
    target = stream->WriteString(4, s, target);
  }

  // .tensorflow.ExecutorOpts exec_opts = 5;
  if (this->_internal_has_exec_opts()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::exec_opts(this),
        _Internal::exec_opts(this).GetCachedSize(), target, stream);
  }

  // bool is_partial = 6;
  if (this->_internal_is_partial() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_is_partial(), target);
  }

  // bool is_last_partial_run = 7;
  if (this->_internal_is_last_partial_run() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_is_last_partial_run(), target);
  }

  // string session_handle = 8;
  if (!this->_internal_session_handle().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RunGraphRequest.session_handle");
    target = stream->WriteStringMaybeAliased(
        8, this->_internal_session_handle(), target);
  }

  // bool store_errors_in_response_body = 9;
  if (this->_internal_store_errors_in_response_body() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_store_errors_in_response_body(), target);
  }

  // bool create_worker_session_called = 10;
  if (this->_internal_create_worker_session_called() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_create_worker_session_called(), target);
  }

  // int64 request_id = 11;
  if (this->_internal_request_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_request_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunGraphRequest)
  return target;
}

size_t RunGraphRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RunGraphRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.NamedTensorProto send = 3;
  total_size += 1UL * this->_internal_send_size();
  for (const auto& msg : this->_impl_.send_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated string recv_key = 4;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.recv_key_.size());
  for (int i = 0, n = _impl_.recv_key_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      _impl_.recv_key_.Get(i));
  }

  // string graph_handle = 1;
  if (!this->_internal_graph_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_graph_handle());
  }

  // string session_handle = 8;
  if (!this->_internal_session_handle().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_session_handle());
  }

  // .tensorflow.ExecutorOpts exec_opts = 5;
  if (this->_internal_has_exec_opts()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.exec_opts_);
  }

  // int64 step_id = 2;
  if (this->_internal_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step_id());
  }

  // int64 request_id = 11;
  if (this->_internal_request_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
  }

  // bool create_worker_session_called = 10;
  if (this->_internal_create_worker_session_called() != 0) {
    total_size += 1 + 1;
  }

  // bool is_partial = 6;
  if (this->_internal_is_partial() != 0) {
    total_size += 1 + 1;
  }

  // bool is_last_partial_run = 7;
  if (this->_internal_is_last_partial_run() != 0) {
    total_size += 1 + 1;
  }

  // bool store_errors_in_response_body = 9;
  if (this->_internal_store_errors_in_response_body() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RunGraphRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RunGraphRequest*>(
      &from));
}

void RunGraphRequest::MergeFrom(const RunGraphRequest& from) {
  RunGraphRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunGraphRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.send_.MergeFrom(from._impl_.send_);
  _this->_impl_.recv_key_.MergeFrom(from._impl_.recv_key_);
  if (!from._internal_graph_handle().empty()) {
    _this->_internal_set_graph_handle(from._internal_graph_handle());
  }
  if (!from._internal_session_handle().empty()) {
    _this->_internal_set_session_handle(from._internal_session_handle());
  }
  if (from._internal_has_exec_opts()) {
    _this->_internal_mutable_exec_opts()->::tensorflow::ExecutorOpts::MergeFrom(
        from._internal_exec_opts());
  }
  if (from._internal_step_id() != 0) {
    _this->_internal_set_step_id(from._internal_step_id());
  }
  if (from._internal_request_id() != 0) {
    _this->_internal_set_request_id(from._internal_request_id());
  }
  if (from._internal_create_worker_session_called() != 0) {
    _this->_internal_set_create_worker_session_called(from._internal_create_worker_session_called());
  }
  if (from._internal_is_partial() != 0) {
    _this->_internal_set_is_partial(from._internal_is_partial());
  }
  if (from._internal_is_last_partial_run() != 0) {
    _this->_internal_set_is_last_partial_run(from._internal_is_last_partial_run());
  }
  if (from._internal_store_errors_in_response_body() != 0) {
    _this->_internal_set_store_errors_in_response_body(from._internal_store_errors_in_response_body());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RunGraphRequest::CopyFrom(const RunGraphRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunGraphRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RunGraphRequest::IsInitialized() const {
  return true;
}

void RunGraphRequest::InternalSwap(RunGraphRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.send_.InternalSwap(&other->_impl_.send_);
  _impl_.recv_key_.InternalSwap(&other->_impl_.recv_key_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.graph_handle_, lhs_arena,
      &other->_impl_.graph_handle_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.session_handle_, lhs_arena,
      &other->_impl_.session_handle_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RunGraphRequest, _impl_.store_errors_in_response_body_)
      + sizeof(RunGraphRequest::_impl_.store_errors_in_response_body_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RunGraphRequest, _impl_.exec_opts_)>(
          reinterpret_cast<char*>(&_impl_.exec_opts_),
          reinterpret_cast<char*>(&other->_impl_.exec_opts_));
}

std::string RunGraphRequest::GetTypeName() const {
  return "tensorflow.RunGraphRequest";
}


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

class RunGraphResponse::_Internal {
 public:
  static const ::tensorflow::StepStats& step_stats(const RunGraphResponse* msg);
  static const ::tensorflow::CostGraphDef& cost_graph(const RunGraphResponse* msg);
};

const ::tensorflow::StepStats&
RunGraphResponse::_Internal::step_stats(const RunGraphResponse* msg) {
  return *msg->_impl_.step_stats_;
}
const ::tensorflow::CostGraphDef&
RunGraphResponse::_Internal::cost_graph(const RunGraphResponse* msg) {
  return *msg->_impl_.cost_graph_;
}
void RunGraphResponse::clear_recv() {
  _impl_.recv_.Clear();
}
void RunGraphResponse::clear_step_stats() {
  if (GetArenaForAllocation() == nullptr && _impl_.step_stats_ != nullptr) {
    delete _impl_.step_stats_;
  }
  _impl_.step_stats_ = nullptr;
}
void RunGraphResponse::clear_cost_graph() {
  if (GetArenaForAllocation() == nullptr && _impl_.cost_graph_ != nullptr) {
    delete _impl_.cost_graph_;
  }
  _impl_.cost_graph_ = nullptr;
}
void RunGraphResponse::clear_partition_graph() {
  _impl_.partition_graph_.Clear();
}
RunGraphResponse::RunGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RunGraphResponse)
}
RunGraphResponse::RunGraphResponse(const RunGraphResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RunGraphResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.recv_){from._impl_.recv_}
    , decltype(_impl_.partition_graph_){from._impl_.partition_graph_}
    , decltype(_impl_.status_error_message_){}
    , decltype(_impl_.step_stats_){nullptr}
    , decltype(_impl_.cost_graph_){nullptr}
    , decltype(_impl_.status_code_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.status_error_message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.status_error_message_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_status_error_message().empty()) {
    _this->_impl_.status_error_message_.Set(from._internal_status_error_message(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_step_stats()) {
    _this->_impl_.step_stats_ = new ::tensorflow::StepStats(*from._impl_.step_stats_);
  }
  if (from._internal_has_cost_graph()) {
    _this->_impl_.cost_graph_ = new ::tensorflow::CostGraphDef(*from._impl_.cost_graph_);
  }
  _this->_impl_.status_code_ = from._impl_.status_code_;
  // @@protoc_insertion_point(copy_constructor:tensorflow.RunGraphResponse)
}

inline void RunGraphResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.recv_){arena}
    , decltype(_impl_.partition_graph_){arena}
    , decltype(_impl_.status_error_message_){}
    , decltype(_impl_.step_stats_){nullptr}
    , decltype(_impl_.cost_graph_){nullptr}
    , decltype(_impl_.status_code_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.status_error_message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.status_error_message_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RunGraphResponse::~RunGraphResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.RunGraphResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RunGraphResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.recv_.~RepeatedPtrField();
  _impl_.partition_graph_.~RepeatedPtrField();
  _impl_.status_error_message_.Destroy();
  if (this != internal_default_instance()) delete _impl_.step_stats_;
  if (this != internal_default_instance()) delete _impl_.cost_graph_;
}

void RunGraphResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RunGraphResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RunGraphResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.recv_.Clear();
  _impl_.partition_graph_.Clear();
  _impl_.status_error_message_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.step_stats_ != nullptr) {
    delete _impl_.step_stats_;
  }
  _impl_.step_stats_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.cost_graph_ != nullptr) {
    delete _impl_.cost_graph_;
  }
  _impl_.cost_graph_ = nullptr;
  _impl_.status_code_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* RunGraphResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .tensorflow.NamedTensorProto recv = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_recv(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.StepStats step_stats = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_step_stats(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.CostGraphDef cost_graph = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_cost_graph(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .tensorflow.GraphDef partition_graph = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_partition_graph(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.error.Code status_code = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_status_code(static_cast<::tensorflow::error::Code>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // string status_error_message = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          auto str = _internal_mutable_status_error_message();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RunGraphResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunGraphResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .tensorflow.NamedTensorProto recv = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_recv_size()); i < n; i++) {
    const auto& repfield = this->_internal_recv(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  // .tensorflow.StepStats step_stats = 2;
  if (this->_internal_has_step_stats()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::step_stats(this),
        _Internal::step_stats(this).GetCachedSize(), target, stream);
  }

  // .tensorflow.CostGraphDef cost_graph = 3;
  if (this->_internal_has_cost_graph()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::cost_graph(this),
        _Internal::cost_graph(this).GetCachedSize(), target, stream);
  }

  // repeated .tensorflow.GraphDef partition_graph = 4;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_partition_graph_size()); i < n; i++) {
    const auto& repfield = this->_internal_partition_graph(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
  }

  // .tensorflow.error.Code status_code = 5;
  if (this->_internal_status_code() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      5, this->_internal_status_code(), target);
  }

  // string status_error_message = 6;
  if (!this->_internal_status_error_message().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_status_error_message().data(), static_cast<int>(this->_internal_status_error_message().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RunGraphResponse.status_error_message");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_status_error_message(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunGraphResponse)
  return target;
}

size_t RunGraphResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RunGraphResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.NamedTensorProto recv = 1;
  total_size += 1UL * this->_internal_recv_size();
  for (const auto& msg : this->_impl_.recv_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .tensorflow.GraphDef partition_graph = 4;
  total_size += 1UL * this->_internal_partition_graph_size();
  for (const auto& msg : this->_impl_.partition_graph_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string status_error_message = 6;
  if (!this->_internal_status_error_message().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_status_error_message());
  }

  // .tensorflow.StepStats step_stats = 2;
  if (this->_internal_has_step_stats()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.step_stats_);
  }

  // .tensorflow.CostGraphDef cost_graph = 3;
  if (this->_internal_has_cost_graph()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.cost_graph_);
  }

  // .tensorflow.error.Code status_code = 5;
  if (this->_internal_status_code() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_status_code());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RunGraphResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RunGraphResponse*>(
      &from));
}

void RunGraphResponse::MergeFrom(const RunGraphResponse& from) {
  RunGraphResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunGraphResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.recv_.MergeFrom(from._impl_.recv_);
  _this->_impl_.partition_graph_.MergeFrom(from._impl_.partition_graph_);
  if (!from._internal_status_error_message().empty()) {
    _this->_internal_set_status_error_message(from._internal_status_error_message());
  }
  if (from._internal_has_step_stats()) {
    _this->_internal_mutable_step_stats()->::tensorflow::StepStats::MergeFrom(
        from._internal_step_stats());
  }
  if (from._internal_has_cost_graph()) {
    _this->_internal_mutable_cost_graph()->::tensorflow::CostGraphDef::MergeFrom(
        from._internal_cost_graph());
  }
  if (from._internal_status_code() != 0) {
    _this->_internal_set_status_code(from._internal_status_code());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RunGraphResponse::CopyFrom(const RunGraphResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunGraphResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RunGraphResponse::IsInitialized() const {
  return true;
}

void RunGraphResponse::InternalSwap(RunGraphResponse* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.recv_.InternalSwap(&other->_impl_.recv_);
  _impl_.partition_graph_.InternalSwap(&other->_impl_.partition_graph_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.status_error_message_, lhs_arena,
      &other->_impl_.status_error_message_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RunGraphResponse, _impl_.status_code_)
      + sizeof(RunGraphResponse::_impl_.status_code_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RunGraphResponse, _impl_.step_stats_)>(
          reinterpret_cast<char*>(&_impl_.step_stats_),
          reinterpret_cast<char*>(&other->_impl_.step_stats_));
}

std::string RunGraphResponse::GetTypeName() const {
  return "tensorflow.RunGraphResponse";
}


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

class CleanupGraphRequest::_Internal {
 public:
};

CleanupGraphRequest::CleanupGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CleanupGraphRequest)
}
CleanupGraphRequest::CleanupGraphRequest(const CleanupGraphRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CleanupGraphRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.step_id_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.step_id_ = from._impl_.step_id_;
  // @@protoc_insertion_point(copy_constructor:tensorflow.CleanupGraphRequest)
}

inline void CleanupGraphRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.step_id_){::int64_t{0}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CleanupGraphRequest::~CleanupGraphRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.CleanupGraphRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CleanupGraphRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CleanupGraphRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CleanupGraphRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CleanupGraphRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.step_id_ = ::int64_t{0};
  _internal_metadata_.Clear<std::string>();
}

const char* CleanupGraphRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 step_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CleanupGraphRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CleanupGraphRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_step_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CleanupGraphRequest)
  return target;
}

size_t CleanupGraphRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CleanupGraphRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CleanupGraphRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CleanupGraphRequest*>(
      &from));
}

void CleanupGraphRequest::MergeFrom(const CleanupGraphRequest& from) {
  CleanupGraphRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CleanupGraphRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_step_id() != 0) {
    _this->_internal_set_step_id(from._internal_step_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CleanupGraphRequest::CopyFrom(const CleanupGraphRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CleanupGraphRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CleanupGraphRequest::IsInitialized() const {
  return true;
}

void CleanupGraphRequest::InternalSwap(CleanupGraphRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.step_id_, other->_impl_.step_id_);
}

std::string CleanupGraphRequest::GetTypeName() const {
  return "tensorflow.CleanupGraphRequest";
}


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

class CleanupGraphResponse::_Internal {
 public:
};

CleanupGraphResponse::CleanupGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CleanupGraphResponse)
}
CleanupGraphResponse::CleanupGraphResponse(const CleanupGraphResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CleanupGraphResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.CleanupGraphResponse)
}

inline void CleanupGraphResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

CleanupGraphResponse::~CleanupGraphResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.CleanupGraphResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CleanupGraphResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CleanupGraphResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CleanupGraphResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CleanupGraphResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* CleanupGraphResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CleanupGraphResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CleanupGraphResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CleanupGraphResponse)
  return target;
}

size_t CleanupGraphResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CleanupGraphResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CleanupGraphResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CleanupGraphResponse*>(
      &from));
}

void CleanupGraphResponse::MergeFrom(const CleanupGraphResponse& from) {
  CleanupGraphResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CleanupGraphResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CleanupGraphResponse::CopyFrom(const CleanupGraphResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CleanupGraphResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CleanupGraphResponse::IsInitialized() const {
  return true;
}

void CleanupGraphResponse::InternalSwap(CleanupGraphResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string CleanupGraphResponse::GetTypeName() const {
  return "tensorflow.CleanupGraphResponse";
}


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

class RecvTensorRequest::_Internal {
 public:
  static const ::tensorflow::DeviceLocality& client_locality(const RecvTensorRequest* msg);
  static const ::tensorflow::DeviceLocality& server_locality(const RecvTensorRequest* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& transport_options(const RecvTensorRequest* msg);
};

const ::tensorflow::DeviceLocality&
RecvTensorRequest::_Internal::client_locality(const RecvTensorRequest* msg) {
  return *msg->_impl_.client_locality_;
}
const ::tensorflow::DeviceLocality&
RecvTensorRequest::_Internal::server_locality(const RecvTensorRequest* msg) {
  return *msg->_impl_.server_locality_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
RecvTensorRequest::_Internal::transport_options(const RecvTensorRequest* msg) {
  return *msg->_impl_.transport_options_;
}
void RecvTensorRequest::clear_client_locality() {
  if (GetArenaForAllocation() == nullptr && _impl_.client_locality_ != nullptr) {
    delete _impl_.client_locality_;
  }
  _impl_.client_locality_ = nullptr;
}
void RecvTensorRequest::clear_server_locality() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_locality_ != nullptr) {
    delete _impl_.server_locality_;
  }
  _impl_.server_locality_ = nullptr;
}
void RecvTensorRequest::clear_transport_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
}
RecvTensorRequest::RecvTensorRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RecvTensorRequest)
}
RecvTensorRequest::RecvTensorRequest(const RecvTensorRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RecvTensorRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.rendezvous_key_){}
    , decltype(_impl_.client_locality_){nullptr}
    , decltype(_impl_.server_locality_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.step_id_){}
    , decltype(_impl_.request_id_){}
    , decltype(_impl_.dma_ok_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.rendezvous_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.rendezvous_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_rendezvous_key().empty()) {
    _this->_impl_.rendezvous_key_.Set(from._internal_rendezvous_key(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_client_locality()) {
    _this->_impl_.client_locality_ = new ::tensorflow::DeviceLocality(*from._impl_.client_locality_);
  }
  if (from._internal_has_server_locality()) {
    _this->_impl_.server_locality_ = new ::tensorflow::DeviceLocality(*from._impl_.server_locality_);
  }
  if (from._internal_has_transport_options()) {
    _this->_impl_.transport_options_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from._impl_.transport_options_);
  }
  ::memcpy(&_impl_.step_id_, &from._impl_.step_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dma_ok_) -
    reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.dma_ok_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RecvTensorRequest)
}

inline void RecvTensorRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.rendezvous_key_){}
    , decltype(_impl_.client_locality_){nullptr}
    , decltype(_impl_.server_locality_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.step_id_){::int64_t{0}}
    , decltype(_impl_.request_id_){::int64_t{0}}
    , decltype(_impl_.dma_ok_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.rendezvous_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.rendezvous_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RecvTensorRequest::~RecvTensorRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.RecvTensorRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RecvTensorRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.rendezvous_key_.Destroy();
  if (this != internal_default_instance()) delete _impl_.client_locality_;
  if (this != internal_default_instance()) delete _impl_.server_locality_;
  if (this != internal_default_instance()) delete _impl_.transport_options_;
}

void RecvTensorRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RecvTensorRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RecvTensorRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.rendezvous_key_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.client_locality_ != nullptr) {
    delete _impl_.client_locality_;
  }
  _impl_.client_locality_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.server_locality_ != nullptr) {
    delete _impl_.server_locality_;
  }
  _impl_.server_locality_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
  ::memset(&_impl_.step_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.dma_ok_) -
      reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.dma_ok_));
  _internal_metadata_.Clear<std::string>();
}

const char* RecvTensorRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 step_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string rendezvous_key = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_rendezvous_key();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // bool dma_ok = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.dma_ok_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DeviceLocality client_locality = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_client_locality(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DeviceLocality server_locality = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_server_locality(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Any transport_options = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_transport_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 request_id = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RecvTensorRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RecvTensorRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_step_id(), target);
  }

  // string rendezvous_key = 2;
  if (!this->_internal_rendezvous_key().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_rendezvous_key().data(), static_cast<int>(this->_internal_rendezvous_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RecvTensorRequest.rendezvous_key");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_rendezvous_key(), target);
  }

  // bool dma_ok = 3;
  if (this->_internal_dma_ok() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_dma_ok(), target);
  }

  // .tensorflow.DeviceLocality client_locality = 4;
  if (this->_internal_has_client_locality()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::client_locality(this),
        _Internal::client_locality(this).GetCachedSize(), target, stream);
  }

  // .tensorflow.DeviceLocality server_locality = 5;
  if (this->_internal_has_server_locality()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::server_locality(this),
        _Internal::server_locality(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Any transport_options = 6;
  if (this->_internal_has_transport_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::transport_options(this),
        _Internal::transport_options(this).GetCachedSize(), target, stream);
  }

  // int64 request_id = 7;
  if (this->_internal_request_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_request_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RecvTensorRequest)
  return target;
}

size_t RecvTensorRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RecvTensorRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string rendezvous_key = 2;
  if (!this->_internal_rendezvous_key().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_rendezvous_key());
  }

  // .tensorflow.DeviceLocality client_locality = 4;
  if (this->_internal_has_client_locality()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.client_locality_);
  }

  // .tensorflow.DeviceLocality server_locality = 5;
  if (this->_internal_has_server_locality()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.server_locality_);
  }

  // .google.protobuf.Any transport_options = 6;
  if (this->_internal_has_transport_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.transport_options_);
  }

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step_id());
  }

  // int64 request_id = 7;
  if (this->_internal_request_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
  }

  // bool dma_ok = 3;
  if (this->_internal_dma_ok() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RecvTensorRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RecvTensorRequest*>(
      &from));
}

void RecvTensorRequest::MergeFrom(const RecvTensorRequest& from) {
  RecvTensorRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RecvTensorRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_rendezvous_key().empty()) {
    _this->_internal_set_rendezvous_key(from._internal_rendezvous_key());
  }
  if (from._internal_has_client_locality()) {
    _this->_internal_mutable_client_locality()->::tensorflow::DeviceLocality::MergeFrom(
        from._internal_client_locality());
  }
  if (from._internal_has_server_locality()) {
    _this->_internal_mutable_server_locality()->::tensorflow::DeviceLocality::MergeFrom(
        from._internal_server_locality());
  }
  if (from._internal_has_transport_options()) {
    _this->_internal_mutable_transport_options()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(
        from._internal_transport_options());
  }
  if (from._internal_step_id() != 0) {
    _this->_internal_set_step_id(from._internal_step_id());
  }
  if (from._internal_request_id() != 0) {
    _this->_internal_set_request_id(from._internal_request_id());
  }
  if (from._internal_dma_ok() != 0) {
    _this->_internal_set_dma_ok(from._internal_dma_ok());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RecvTensorRequest::CopyFrom(const RecvTensorRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RecvTensorRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvTensorRequest::IsInitialized() const {
  return true;
}

void RecvTensorRequest::InternalSwap(RecvTensorRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.rendezvous_key_, lhs_arena,
      &other->_impl_.rendezvous_key_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RecvTensorRequest, _impl_.dma_ok_)
      + sizeof(RecvTensorRequest::_impl_.dma_ok_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RecvTensorRequest, _impl_.client_locality_)>(
          reinterpret_cast<char*>(&_impl_.client_locality_),
          reinterpret_cast<char*>(&other->_impl_.client_locality_));
}

std::string RecvTensorRequest::GetTypeName() const {
  return "tensorflow.RecvTensorRequest";
}


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

class RecvTensorResponse::_Internal {
 public:
  static const ::tensorflow::TensorProto& tensor(const RecvTensorResponse* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& transport_options(const RecvTensorResponse* msg);
};

const ::tensorflow::TensorProto&
RecvTensorResponse::_Internal::tensor(const RecvTensorResponse* msg) {
  return *msg->_impl_.tensor_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
RecvTensorResponse::_Internal::transport_options(const RecvTensorResponse* msg) {
  return *msg->_impl_.transport_options_;
}
void RecvTensorResponse::clear_tensor() {
  if (GetArenaForAllocation() == nullptr && _impl_.tensor_ != nullptr) {
    delete _impl_.tensor_;
  }
  _impl_.tensor_ = nullptr;
}
void RecvTensorResponse::clear_transport_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
}
RecvTensorResponse::RecvTensorResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RecvTensorResponse)
}
RecvTensorResponse::RecvTensorResponse(const RecvTensorResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RecvTensorResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.tensor_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.send_start_micros_){}
    , decltype(_impl_.is_dead_){}
    , decltype(_impl_.require_ack_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_tensor()) {
    _this->_impl_.tensor_ = new ::tensorflow::TensorProto(*from._impl_.tensor_);
  }
  if (from._internal_has_transport_options()) {
    _this->_impl_.transport_options_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from._impl_.transport_options_);
  }
  ::memcpy(&_impl_.send_start_micros_, &from._impl_.send_start_micros_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.require_ack_) -
    reinterpret_cast<char*>(&_impl_.send_start_micros_)) + sizeof(_impl_.require_ack_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RecvTensorResponse)
}

inline void RecvTensorResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.tensor_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.send_start_micros_){::int64_t{0}}
    , decltype(_impl_.is_dead_){false}
    , decltype(_impl_.require_ack_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

RecvTensorResponse::~RecvTensorResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.RecvTensorResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RecvTensorResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.tensor_;
  if (this != internal_default_instance()) delete _impl_.transport_options_;
}

void RecvTensorResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RecvTensorResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RecvTensorResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.tensor_ != nullptr) {
    delete _impl_.tensor_;
  }
  _impl_.tensor_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
  ::memset(&_impl_.send_start_micros_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.require_ack_) -
      reinterpret_cast<char*>(&_impl_.send_start_micros_)) + sizeof(_impl_.require_ack_));
  _internal_metadata_.Clear<std::string>();
}

const char* RecvTensorResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .tensorflow.TensorProto tensor = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_tensor(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_dead = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.is_dead_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 send_start_micros = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.send_start_micros_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Any transport_options = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_transport_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool require_ack = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.require_ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RecvTensorResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RecvTensorResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .tensorflow.TensorProto tensor = 1;
  if (this->_internal_has_tensor()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::tensor(this),
        _Internal::tensor(this).GetCachedSize(), target, stream);
  }

  // bool is_dead = 2;
  if (this->_internal_is_dead() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_is_dead(), target);
  }

  // int64 send_start_micros = 3;
  if (this->_internal_send_start_micros() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_send_start_micros(), target);
  }

  // .google.protobuf.Any transport_options = 4;
  if (this->_internal_has_transport_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::transport_options(this),
        _Internal::transport_options(this).GetCachedSize(), target, stream);
  }

  // bool require_ack = 5;
  if (this->_internal_require_ack() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_require_ack(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RecvTensorResponse)
  return target;
}

size_t RecvTensorResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RecvTensorResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .tensorflow.TensorProto tensor = 1;
  if (this->_internal_has_tensor()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.tensor_);
  }

  // .google.protobuf.Any transport_options = 4;
  if (this->_internal_has_transport_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.transport_options_);
  }

  // int64 send_start_micros = 3;
  if (this->_internal_send_start_micros() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_send_start_micros());
  }

  // bool is_dead = 2;
  if (this->_internal_is_dead() != 0) {
    total_size += 1 + 1;
  }

  // bool require_ack = 5;
  if (this->_internal_require_ack() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RecvTensorResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RecvTensorResponse*>(
      &from));
}

void RecvTensorResponse::MergeFrom(const RecvTensorResponse& from) {
  RecvTensorResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RecvTensorResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_tensor()) {
    _this->_internal_mutable_tensor()->::tensorflow::TensorProto::MergeFrom(
        from._internal_tensor());
  }
  if (from._internal_has_transport_options()) {
    _this->_internal_mutable_transport_options()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(
        from._internal_transport_options());
  }
  if (from._internal_send_start_micros() != 0) {
    _this->_internal_set_send_start_micros(from._internal_send_start_micros());
  }
  if (from._internal_is_dead() != 0) {
    _this->_internal_set_is_dead(from._internal_is_dead());
  }
  if (from._internal_require_ack() != 0) {
    _this->_internal_set_require_ack(from._internal_require_ack());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RecvTensorResponse::CopyFrom(const RecvTensorResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RecvTensorResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvTensorResponse::IsInitialized() const {
  return true;
}

void RecvTensorResponse::InternalSwap(RecvTensorResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RecvTensorResponse, _impl_.require_ack_)
      + sizeof(RecvTensorResponse::_impl_.require_ack_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RecvTensorResponse, _impl_.tensor_)>(
          reinterpret_cast<char*>(&_impl_.tensor_),
          reinterpret_cast<char*>(&other->_impl_.tensor_));
}

std::string RecvTensorResponse::GetTypeName() const {
  return "tensorflow.RecvTensorResponse";
}


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

class MarkRecvFinishedRequest::_Internal {
 public:
};

MarkRecvFinishedRequest::MarkRecvFinishedRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.MarkRecvFinishedRequest)
}
MarkRecvFinishedRequest::MarkRecvFinishedRequest(const MarkRecvFinishedRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  MarkRecvFinishedRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.request_id_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.request_id_ = from._impl_.request_id_;
  // @@protoc_insertion_point(copy_constructor:tensorflow.MarkRecvFinishedRequest)
}

inline void MarkRecvFinishedRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.request_id_){::int64_t{0}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

MarkRecvFinishedRequest::~MarkRecvFinishedRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.MarkRecvFinishedRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MarkRecvFinishedRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MarkRecvFinishedRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MarkRecvFinishedRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.MarkRecvFinishedRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.request_id_ = ::int64_t{0};
  _internal_metadata_.Clear<std::string>();
}

const char* MarkRecvFinishedRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 request_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* MarkRecvFinishedRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.MarkRecvFinishedRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 request_id = 1;
  if (this->_internal_request_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_request_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.MarkRecvFinishedRequest)
  return target;
}

size_t MarkRecvFinishedRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.MarkRecvFinishedRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int64 request_id = 1;
  if (this->_internal_request_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MarkRecvFinishedRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const MarkRecvFinishedRequest*>(
      &from));
}

void MarkRecvFinishedRequest::MergeFrom(const MarkRecvFinishedRequest& from) {
  MarkRecvFinishedRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.MarkRecvFinishedRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_request_id() != 0) {
    _this->_internal_set_request_id(from._internal_request_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MarkRecvFinishedRequest::CopyFrom(const MarkRecvFinishedRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.MarkRecvFinishedRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MarkRecvFinishedRequest::IsInitialized() const {
  return true;
}

void MarkRecvFinishedRequest::InternalSwap(MarkRecvFinishedRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.request_id_, other->_impl_.request_id_);
}

std::string MarkRecvFinishedRequest::GetTypeName() const {
  return "tensorflow.MarkRecvFinishedRequest";
}


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

class MarkRecvFinishedResponse::_Internal {
 public:
};

MarkRecvFinishedResponse::MarkRecvFinishedResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.MarkRecvFinishedResponse)
}
MarkRecvFinishedResponse::MarkRecvFinishedResponse(const MarkRecvFinishedResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  MarkRecvFinishedResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.MarkRecvFinishedResponse)
}

inline void MarkRecvFinishedResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

MarkRecvFinishedResponse::~MarkRecvFinishedResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.MarkRecvFinishedResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MarkRecvFinishedResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MarkRecvFinishedResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MarkRecvFinishedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.MarkRecvFinishedResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* MarkRecvFinishedResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* MarkRecvFinishedResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.MarkRecvFinishedResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.MarkRecvFinishedResponse)
  return target;
}

size_t MarkRecvFinishedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.MarkRecvFinishedResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MarkRecvFinishedResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const MarkRecvFinishedResponse*>(
      &from));
}

void MarkRecvFinishedResponse::MergeFrom(const MarkRecvFinishedResponse& from) {
  MarkRecvFinishedResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.MarkRecvFinishedResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MarkRecvFinishedResponse::CopyFrom(const MarkRecvFinishedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.MarkRecvFinishedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MarkRecvFinishedResponse::IsInitialized() const {
  return true;
}

void MarkRecvFinishedResponse::InternalSwap(MarkRecvFinishedResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string MarkRecvFinishedResponse::GetTypeName() const {
  return "tensorflow.MarkRecvFinishedResponse";
}


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

class LoggingRequest::_Internal {
 public:
};

LoggingRequest::LoggingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.LoggingRequest)
}
LoggingRequest::LoggingRequest(const LoggingRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  LoggingRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.fetch_step_id_){from._impl_.fetch_step_id_}
    , /*decltype(_impl_._fetch_step_id_cached_byte_size_)*/{0}
    , decltype(_impl_.enable_rpc_logging_){}
    , decltype(_impl_.disable_rpc_logging_){}
    , decltype(_impl_.clear_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.enable_rpc_logging_, &from._impl_.enable_rpc_logging_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.clear_) -
    reinterpret_cast<char*>(&_impl_.enable_rpc_logging_)) + sizeof(_impl_.clear_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.LoggingRequest)
}

inline void LoggingRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.fetch_step_id_){arena}
    , /*decltype(_impl_._fetch_step_id_cached_byte_size_)*/{0}
    , decltype(_impl_.enable_rpc_logging_){false}
    , decltype(_impl_.disable_rpc_logging_){false}
    , decltype(_impl_.clear_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

LoggingRequest::~LoggingRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.LoggingRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void LoggingRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.fetch_step_id_.~RepeatedField();
}

void LoggingRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void LoggingRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.LoggingRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.fetch_step_id_.Clear();
  ::memset(&_impl_.enable_rpc_logging_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.clear_) -
      reinterpret_cast<char*>(&_impl_.enable_rpc_logging_)) + sizeof(_impl_.clear_));
  _internal_metadata_.Clear<std::string>();
}

const char* LoggingRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool enable_rpc_logging = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.enable_rpc_logging_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool clear = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.clear_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int64 fetch_step_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_fetch_step_id(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          _internal_add_fetch_step_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool disable_rpc_logging = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.disable_rpc_logging_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* LoggingRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.LoggingRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool enable_rpc_logging = 1;
  if (this->_internal_enable_rpc_logging() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_enable_rpc_logging(), target);
  }

  // bool clear = 2;
  if (this->_internal_clear() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_clear(), target);
  }

  // repeated int64 fetch_step_id = 3;
  {
    int byte_size = _impl_._fetch_step_id_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(
          3, _internal_fetch_step_id(), byte_size, target);
    }
  }

  // bool disable_rpc_logging = 4;
  if (this->_internal_disable_rpc_logging() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_disable_rpc_logging(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.LoggingRequest)
  return target;
}

size_t LoggingRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.LoggingRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int64 fetch_step_id = 3;
  {
    size_t data_size = ::_pbi::WireFormatLite::
      Int64Size(this->_impl_.fetch_step_id_);
    if (data_size > 0) {
      total_size += 1 +
        ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
    }
    int cached_size = ::_pbi::ToCachedSize(data_size);
    _impl_._fetch_step_id_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // bool enable_rpc_logging = 1;
  if (this->_internal_enable_rpc_logging() != 0) {
    total_size += 1 + 1;
  }

  // bool disable_rpc_logging = 4;
  if (this->_internal_disable_rpc_logging() != 0) {
    total_size += 1 + 1;
  }

  // bool clear = 2;
  if (this->_internal_clear() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LoggingRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const LoggingRequest*>(
      &from));
}

void LoggingRequest::MergeFrom(const LoggingRequest& from) {
  LoggingRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.LoggingRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.fetch_step_id_.MergeFrom(from._impl_.fetch_step_id_);
  if (from._internal_enable_rpc_logging() != 0) {
    _this->_internal_set_enable_rpc_logging(from._internal_enable_rpc_logging());
  }
  if (from._internal_disable_rpc_logging() != 0) {
    _this->_internal_set_disable_rpc_logging(from._internal_disable_rpc_logging());
  }
  if (from._internal_clear() != 0) {
    _this->_internal_set_clear(from._internal_clear());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void LoggingRequest::CopyFrom(const LoggingRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.LoggingRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoggingRequest::IsInitialized() const {
  return true;
}

void LoggingRequest::InternalSwap(LoggingRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.fetch_step_id_.InternalSwap(&other->_impl_.fetch_step_id_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LoggingRequest, _impl_.clear_)
      + sizeof(LoggingRequest::_impl_.clear_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(LoggingRequest, _impl_.enable_rpc_logging_)>(
          reinterpret_cast<char*>(&_impl_.enable_rpc_logging_),
          reinterpret_cast<char*>(&other->_impl_.enable_rpc_logging_));
}

std::string LoggingRequest::GetTypeName() const {
  return "tensorflow.LoggingRequest";
}


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

class LabeledStepStats::_Internal {
 public:
  static const ::tensorflow::StepStats& step_stats(const LabeledStepStats* msg);
};

const ::tensorflow::StepStats&
LabeledStepStats::_Internal::step_stats(const LabeledStepStats* msg) {
  return *msg->_impl_.step_stats_;
}
void LabeledStepStats::clear_step_stats() {
  if (GetArenaForAllocation() == nullptr && _impl_.step_stats_ != nullptr) {
    delete _impl_.step_stats_;
  }
  _impl_.step_stats_ = nullptr;
}
LabeledStepStats::LabeledStepStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.LabeledStepStats)
}
LabeledStepStats::LabeledStepStats(const LabeledStepStats& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  LabeledStepStats* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.step_stats_){nullptr}
    , decltype(_impl_.step_id_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_step_stats()) {
    _this->_impl_.step_stats_ = new ::tensorflow::StepStats(*from._impl_.step_stats_);
  }
  _this->_impl_.step_id_ = from._impl_.step_id_;
  // @@protoc_insertion_point(copy_constructor:tensorflow.LabeledStepStats)
}

inline void LabeledStepStats::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.step_stats_){nullptr}
    , decltype(_impl_.step_id_){::int64_t{0}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

LabeledStepStats::~LabeledStepStats() {
  // @@protoc_insertion_point(destructor:tensorflow.LabeledStepStats)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void LabeledStepStats::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.step_stats_;
}

void LabeledStepStats::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void LabeledStepStats::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.LabeledStepStats)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.step_stats_ != nullptr) {
    delete _impl_.step_stats_;
  }
  _impl_.step_stats_ = nullptr;
  _impl_.step_id_ = ::int64_t{0};
  _internal_metadata_.Clear<std::string>();
}

const char* LabeledStepStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 step_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.StepStats step_stats = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_step_stats(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* LabeledStepStats::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.LabeledStepStats)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_step_id(), target);
  }

  // .tensorflow.StepStats step_stats = 2;
  if (this->_internal_has_step_stats()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::step_stats(this),
        _Internal::step_stats(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.LabeledStepStats)
  return target;
}

size_t LabeledStepStats::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.LabeledStepStats)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .tensorflow.StepStats step_stats = 2;
  if (this->_internal_has_step_stats()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.step_stats_);
  }

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LabeledStepStats::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const LabeledStepStats*>(
      &from));
}

void LabeledStepStats::MergeFrom(const LabeledStepStats& from) {
  LabeledStepStats* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.LabeledStepStats)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_step_stats()) {
    _this->_internal_mutable_step_stats()->::tensorflow::StepStats::MergeFrom(
        from._internal_step_stats());
  }
  if (from._internal_step_id() != 0) {
    _this->_internal_set_step_id(from._internal_step_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void LabeledStepStats::CopyFrom(const LabeledStepStats& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.LabeledStepStats)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LabeledStepStats::IsInitialized() const {
  return true;
}

void LabeledStepStats::InternalSwap(LabeledStepStats* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LabeledStepStats, _impl_.step_id_)
      + sizeof(LabeledStepStats::_impl_.step_id_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(LabeledStepStats, _impl_.step_stats_)>(
          reinterpret_cast<char*>(&_impl_.step_stats_),
          reinterpret_cast<char*>(&other->_impl_.step_stats_));
}

std::string LabeledStepStats::GetTypeName() const {
  return "tensorflow.LabeledStepStats";
}


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

class LoggingResponse::_Internal {
 public:
};

LoggingResponse::LoggingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.LoggingResponse)
}
LoggingResponse::LoggingResponse(const LoggingResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  LoggingResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.step_){from._impl_.step_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.LoggingResponse)
}

inline void LoggingResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.step_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

LoggingResponse::~LoggingResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.LoggingResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void LoggingResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.step_.~RepeatedPtrField();
}

void LoggingResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void LoggingResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.LoggingResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.step_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* LoggingResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .tensorflow.LabeledStepStats step = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_step(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* LoggingResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.LoggingResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .tensorflow.LabeledStepStats step = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_step_size()); i < n; i++) {
    const auto& repfield = this->_internal_step(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.LoggingResponse)
  return target;
}

size_t LoggingResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.LoggingResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.LabeledStepStats step = 1;
  total_size += 1UL * this->_internal_step_size();
  for (const auto& msg : this->_impl_.step_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LoggingResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const LoggingResponse*>(
      &from));
}

void LoggingResponse::MergeFrom(const LoggingResponse& from) {
  LoggingResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.LoggingResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.step_.MergeFrom(from._impl_.step_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void LoggingResponse::CopyFrom(const LoggingResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.LoggingResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoggingResponse::IsInitialized() const {
  return true;
}

void LoggingResponse::InternalSwap(LoggingResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.step_.InternalSwap(&other->_impl_.step_);
}

std::string LoggingResponse::GetTypeName() const {
  return "tensorflow.LoggingResponse";
}


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

class TraceOpts::_Internal {
 public:
};

TraceOpts::TraceOpts(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.TraceOpts)
}
TraceOpts::TraceOpts(const TraceOpts& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TraceOpts* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.duration_){}
    , decltype(_impl_.use_step_profiler_){}
    , decltype(_impl_.use_kernel_profiler_){}
    , decltype(_impl_.use_extended_profiler_){}
    , decltype(_impl_.use_gpu_profiler_){}
    , decltype(_impl_.use_sample_profiler_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.duration_, &from._impl_.duration_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.use_sample_profiler_) -
    reinterpret_cast<char*>(&_impl_.duration_)) + sizeof(_impl_.use_sample_profiler_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.TraceOpts)
}

inline void TraceOpts::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.duration_){0}
    , decltype(_impl_.use_step_profiler_){false}
    , decltype(_impl_.use_kernel_profiler_){false}
    , decltype(_impl_.use_extended_profiler_){false}
    , decltype(_impl_.use_gpu_profiler_){false}
    , decltype(_impl_.use_sample_profiler_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

TraceOpts::~TraceOpts() {
  // @@protoc_insertion_point(destructor:tensorflow.TraceOpts)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void TraceOpts::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void TraceOpts::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void TraceOpts::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.TraceOpts)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.duration_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.use_sample_profiler_) -
      reinterpret_cast<char*>(&_impl_.duration_)) + sizeof(_impl_.use_sample_profiler_));
  _internal_metadata_.Clear<std::string>();
}

const char* TraceOpts::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // double duration = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
          _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool use_step_profiler = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.use_step_profiler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool use_kernel_profiler = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.use_kernel_profiler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool use_extended_profiler = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.use_extended_profiler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool use_gpu_profiler = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.use_gpu_profiler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool use_sample_profiler = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.use_sample_profiler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* TraceOpts::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TraceOpts)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // double duration = 1;
  static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_duration = this->_internal_duration();
  ::uint64_t raw_duration;
  memcpy(&raw_duration, &tmp_duration, sizeof(tmp_duration));
  if (raw_duration != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_duration(), target);
  }

  // bool use_step_profiler = 2;
  if (this->_internal_use_step_profiler() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_use_step_profiler(), target);
  }

  // bool use_kernel_profiler = 3;
  if (this->_internal_use_kernel_profiler() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_use_kernel_profiler(), target);
  }

  // bool use_extended_profiler = 4;
  if (this->_internal_use_extended_profiler() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_use_extended_profiler(), target);
  }

  // bool use_gpu_profiler = 5;
  if (this->_internal_use_gpu_profiler() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_use_gpu_profiler(), target);
  }

  // bool use_sample_profiler = 6;
  if (this->_internal_use_sample_profiler() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_use_sample_profiler(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TraceOpts)
  return target;
}

size_t TraceOpts::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.TraceOpts)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // double duration = 1;
  static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_duration = this->_internal_duration();
  ::uint64_t raw_duration;
  memcpy(&raw_duration, &tmp_duration, sizeof(tmp_duration));
  if (raw_duration != 0) {
    total_size += 1 + 8;
  }

  // bool use_step_profiler = 2;
  if (this->_internal_use_step_profiler() != 0) {
    total_size += 1 + 1;
  }

  // bool use_kernel_profiler = 3;
  if (this->_internal_use_kernel_profiler() != 0) {
    total_size += 1 + 1;
  }

  // bool use_extended_profiler = 4;
  if (this->_internal_use_extended_profiler() != 0) {
    total_size += 1 + 1;
  }

  // bool use_gpu_profiler = 5;
  if (this->_internal_use_gpu_profiler() != 0) {
    total_size += 1 + 1;
  }

  // bool use_sample_profiler = 6;
  if (this->_internal_use_sample_profiler() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TraceOpts::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const TraceOpts*>(
      &from));
}

void TraceOpts::MergeFrom(const TraceOpts& from) {
  TraceOpts* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TraceOpts)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_duration = from._internal_duration();
  ::uint64_t raw_duration;
  memcpy(&raw_duration, &tmp_duration, sizeof(tmp_duration));
  if (raw_duration != 0) {
    _this->_internal_set_duration(from._internal_duration());
  }
  if (from._internal_use_step_profiler() != 0) {
    _this->_internal_set_use_step_profiler(from._internal_use_step_profiler());
  }
  if (from._internal_use_kernel_profiler() != 0) {
    _this->_internal_set_use_kernel_profiler(from._internal_use_kernel_profiler());
  }
  if (from._internal_use_extended_profiler() != 0) {
    _this->_internal_set_use_extended_profiler(from._internal_use_extended_profiler());
  }
  if (from._internal_use_gpu_profiler() != 0) {
    _this->_internal_set_use_gpu_profiler(from._internal_use_gpu_profiler());
  }
  if (from._internal_use_sample_profiler() != 0) {
    _this->_internal_set_use_sample_profiler(from._internal_use_sample_profiler());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void TraceOpts::CopyFrom(const TraceOpts& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TraceOpts)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TraceOpts::IsInitialized() const {
  return true;
}

void TraceOpts::InternalSwap(TraceOpts* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TraceOpts, _impl_.use_sample_profiler_)
      + sizeof(TraceOpts::_impl_.use_sample_profiler_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(TraceOpts, _impl_.duration_)>(
          reinterpret_cast<char*>(&_impl_.duration_),
          reinterpret_cast<char*>(&other->_impl_.duration_));
}

std::string TraceOpts::GetTypeName() const {
  return "tensorflow.TraceOpts";
}


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

class TracingRequest::_Internal {
 public:
  static const ::tensorflow::TraceOpts& options(const TracingRequest* msg);
};

const ::tensorflow::TraceOpts&
TracingRequest::_Internal::options(const TracingRequest* msg) {
  return *msg->_impl_.options_;
}
TracingRequest::TracingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.TracingRequest)
}
TracingRequest::TracingRequest(const TracingRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TracingRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.options_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_options()) {
    _this->_impl_.options_ = new ::tensorflow::TraceOpts(*from._impl_.options_);
  }
  // @@protoc_insertion_point(copy_constructor:tensorflow.TracingRequest)
}

inline void TracingRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.options_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

TracingRequest::~TracingRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.TracingRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void TracingRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.options_;
}

void TracingRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void TracingRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.TracingRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
    delete _impl_.options_;
  }
  _impl_.options_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* TracingRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .tensorflow.TraceOpts options = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* TracingRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TracingRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .tensorflow.TraceOpts options = 1;
  if (this->_internal_has_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::options(this),
        _Internal::options(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TracingRequest)
  return target;
}

size_t TracingRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.TracingRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .tensorflow.TraceOpts options = 1;
  if (this->_internal_has_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.options_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TracingRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const TracingRequest*>(
      &from));
}

void TracingRequest::MergeFrom(const TracingRequest& from) {
  TracingRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TracingRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_options()) {
    _this->_internal_mutable_options()->::tensorflow::TraceOpts::MergeFrom(
        from._internal_options());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void TracingRequest::CopyFrom(const TracingRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TracingRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TracingRequest::IsInitialized() const {
  return true;
}

void TracingRequest::InternalSwap(TracingRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.options_, other->_impl_.options_);
}

std::string TracingRequest::GetTypeName() const {
  return "tensorflow.TracingRequest";
}


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

class TracingResponse::_Internal {
 public:
};

TracingResponse::TracingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.TracingResponse)
}
TracingResponse::TracingResponse(const TracingResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TracingResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.TracingResponse)
}

inline void TracingResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

TracingResponse::~TracingResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.TracingResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void TracingResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void TracingResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void TracingResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.TracingResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* TracingResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* TracingResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TracingResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TracingResponse)
  return target;
}

size_t TracingResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.TracingResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TracingResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const TracingResponse*>(
      &from));
}

void TracingResponse::MergeFrom(const TracingResponse& from) {
  TracingResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TracingResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void TracingResponse::CopyFrom(const TracingResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TracingResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TracingResponse::IsInitialized() const {
  return true;
}

void TracingResponse::InternalSwap(TracingResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string TracingResponse::GetTypeName() const {
  return "tensorflow.TracingResponse";
}


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

class RecvBufRequest::_Internal {
 public:
  static const ::tensorflow::DeviceLocality& client_locality(const RecvBufRequest* msg);
  static const ::tensorflow::DeviceLocality& server_locality(const RecvBufRequest* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& transport_options(const RecvBufRequest* msg);
};

const ::tensorflow::DeviceLocality&
RecvBufRequest::_Internal::client_locality(const RecvBufRequest* msg) {
  return *msg->_impl_.client_locality_;
}
const ::tensorflow::DeviceLocality&
RecvBufRequest::_Internal::server_locality(const RecvBufRequest* msg) {
  return *msg->_impl_.server_locality_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
RecvBufRequest::_Internal::transport_options(const RecvBufRequest* msg) {
  return *msg->_impl_.transport_options_;
}
void RecvBufRequest::clear_client_locality() {
  if (GetArenaForAllocation() == nullptr && _impl_.client_locality_ != nullptr) {
    delete _impl_.client_locality_;
  }
  _impl_.client_locality_ = nullptr;
}
void RecvBufRequest::clear_server_locality() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_locality_ != nullptr) {
    delete _impl_.server_locality_;
  }
  _impl_.server_locality_ = nullptr;
}
void RecvBufRequest::clear_transport_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
}
RecvBufRequest::RecvBufRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RecvBufRequest)
}
RecvBufRequest::RecvBufRequest(const RecvBufRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RecvBufRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.buf_rendezvous_key_){}
    , decltype(_impl_.src_device_){}
    , decltype(_impl_.dst_device_){}
    , decltype(_impl_.client_locality_){nullptr}
    , decltype(_impl_.server_locality_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.step_id_){}
    , decltype(_impl_.num_bytes_){}
    , decltype(_impl_.buf_ptr_){}
    , decltype(_impl_.request_id_){}
    , decltype(_impl_.src_incarnation_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.buf_rendezvous_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.buf_rendezvous_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_buf_rendezvous_key().empty()) {
    _this->_impl_.buf_rendezvous_key_.Set(from._internal_buf_rendezvous_key(),
      _this->GetArenaForAllocation());
  }
  _impl_.src_device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.src_device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_src_device().empty()) {
    _this->_impl_.src_device_.Set(from._internal_src_device(),
      _this->GetArenaForAllocation());
  }
  _impl_.dst_device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.dst_device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_dst_device().empty()) {
    _this->_impl_.dst_device_.Set(from._internal_dst_device(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_client_locality()) {
    _this->_impl_.client_locality_ = new ::tensorflow::DeviceLocality(*from._impl_.client_locality_);
  }
  if (from._internal_has_server_locality()) {
    _this->_impl_.server_locality_ = new ::tensorflow::DeviceLocality(*from._impl_.server_locality_);
  }
  if (from._internal_has_transport_options()) {
    _this->_impl_.transport_options_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from._impl_.transport_options_);
  }
  ::memcpy(&_impl_.step_id_, &from._impl_.step_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.src_incarnation_) -
    reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.src_incarnation_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RecvBufRequest)
}

inline void RecvBufRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.buf_rendezvous_key_){}
    , decltype(_impl_.src_device_){}
    , decltype(_impl_.dst_device_){}
    , decltype(_impl_.client_locality_){nullptr}
    , decltype(_impl_.server_locality_){nullptr}
    , decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.step_id_){::int64_t{0}}
    , decltype(_impl_.num_bytes_){::int64_t{0}}
    , decltype(_impl_.buf_ptr_){::uint64_t{0u}}
    , decltype(_impl_.request_id_){::int64_t{0}}
    , decltype(_impl_.src_incarnation_){::uint64_t{0u}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.buf_rendezvous_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.buf_rendezvous_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.src_device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.src_device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.dst_device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.dst_device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

RecvBufRequest::~RecvBufRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.RecvBufRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RecvBufRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.buf_rendezvous_key_.Destroy();
  _impl_.src_device_.Destroy();
  _impl_.dst_device_.Destroy();
  if (this != internal_default_instance()) delete _impl_.client_locality_;
  if (this != internal_default_instance()) delete _impl_.server_locality_;
  if (this != internal_default_instance()) delete _impl_.transport_options_;
}

void RecvBufRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RecvBufRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RecvBufRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.buf_rendezvous_key_.ClearToEmpty();
  _impl_.src_device_.ClearToEmpty();
  _impl_.dst_device_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.client_locality_ != nullptr) {
    delete _impl_.client_locality_;
  }
  _impl_.client_locality_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.server_locality_ != nullptr) {
    delete _impl_.server_locality_;
  }
  _impl_.server_locality_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
  ::memset(&_impl_.step_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.src_incarnation_) -
      reinterpret_cast<char*>(&_impl_.step_id_)) + sizeof(_impl_.src_incarnation_));
  _internal_metadata_.Clear<std::string>();
}

const char* RecvBufRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 step_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string buf_rendezvous_key = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_buf_rendezvous_key();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 num_bytes = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.num_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // fixed64 buf_ptr = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 33)) {
          _impl_.buf_ptr_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
          ptr += sizeof(::uint64_t);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DeviceLocality client_locality = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_client_locality(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DeviceLocality server_locality = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_server_locality(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Any transport_options = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_transport_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string src_device = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          auto str = _internal_mutable_src_device();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string dst_device = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
          auto str = _internal_mutable_dst_device();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 request_id = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
          _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // uint64 src_incarnation = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
          _impl_.src_incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RecvBufRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RecvBufRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_step_id(), target);
  }

  // string buf_rendezvous_key = 2;
  if (!this->_internal_buf_rendezvous_key().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_buf_rendezvous_key().data(), static_cast<int>(this->_internal_buf_rendezvous_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RecvBufRequest.buf_rendezvous_key");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_buf_rendezvous_key(), target);
  }

  // int64 num_bytes = 3;
  if (this->_internal_num_bytes() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_num_bytes(), target);
  }

  // fixed64 buf_ptr = 4;
  if (this->_internal_buf_ptr() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(4, this->_internal_buf_ptr(), target);
  }

  // .tensorflow.DeviceLocality client_locality = 5;
  if (this->_internal_has_client_locality()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::client_locality(this),
        _Internal::client_locality(this).GetCachedSize(), target, stream);
  }

  // .tensorflow.DeviceLocality server_locality = 6;
  if (this->_internal_has_server_locality()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::server_locality(this),
        _Internal::server_locality(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Any transport_options = 7;
  if (this->_internal_has_transport_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::transport_options(this),
        _Internal::transport_options(this).GetCachedSize(), target, stream);
  }

  // string src_device = 8;
  if (!this->_internal_src_device().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_src_device().data(), static_cast<int>(this->_internal_src_device().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RecvBufRequest.src_device");
    target = stream->WriteStringMaybeAliased(
        8, this->_internal_src_device(), target);
  }

  // string dst_device = 9;
  if (!this->_internal_dst_device().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_dst_device().data(), static_cast<int>(this->_internal_dst_device().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.RecvBufRequest.dst_device");
    target = stream->WriteStringMaybeAliased(
        9, this->_internal_dst_device(), target);
  }

  // int64 request_id = 10;
  if (this->_internal_request_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_request_id(), target);
  }

  // uint64 src_incarnation = 11;
  if (this->_internal_src_incarnation() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(11, this->_internal_src_incarnation(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RecvBufRequest)
  return target;
}

size_t RecvBufRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RecvBufRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string buf_rendezvous_key = 2;
  if (!this->_internal_buf_rendezvous_key().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_buf_rendezvous_key());
  }

  // string src_device = 8;
  if (!this->_internal_src_device().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_src_device());
  }

  // string dst_device = 9;
  if (!this->_internal_dst_device().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_dst_device());
  }

  // .tensorflow.DeviceLocality client_locality = 5;
  if (this->_internal_has_client_locality()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.client_locality_);
  }

  // .tensorflow.DeviceLocality server_locality = 6;
  if (this->_internal_has_server_locality()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.server_locality_);
  }

  // .google.protobuf.Any transport_options = 7;
  if (this->_internal_has_transport_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.transport_options_);
  }

  // int64 step_id = 1;
  if (this->_internal_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step_id());
  }

  // int64 num_bytes = 3;
  if (this->_internal_num_bytes() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_num_bytes());
  }

  // fixed64 buf_ptr = 4;
  if (this->_internal_buf_ptr() != 0) {
    total_size += 1 + 8;
  }

  // int64 request_id = 10;
  if (this->_internal_request_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
  }

  // uint64 src_incarnation = 11;
  if (this->_internal_src_incarnation() != 0) {
    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_src_incarnation());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RecvBufRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RecvBufRequest*>(
      &from));
}

void RecvBufRequest::MergeFrom(const RecvBufRequest& from) {
  RecvBufRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RecvBufRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_buf_rendezvous_key().empty()) {
    _this->_internal_set_buf_rendezvous_key(from._internal_buf_rendezvous_key());
  }
  if (!from._internal_src_device().empty()) {
    _this->_internal_set_src_device(from._internal_src_device());
  }
  if (!from._internal_dst_device().empty()) {
    _this->_internal_set_dst_device(from._internal_dst_device());
  }
  if (from._internal_has_client_locality()) {
    _this->_internal_mutable_client_locality()->::tensorflow::DeviceLocality::MergeFrom(
        from._internal_client_locality());
  }
  if (from._internal_has_server_locality()) {
    _this->_internal_mutable_server_locality()->::tensorflow::DeviceLocality::MergeFrom(
        from._internal_server_locality());
  }
  if (from._internal_has_transport_options()) {
    _this->_internal_mutable_transport_options()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(
        from._internal_transport_options());
  }
  if (from._internal_step_id() != 0) {
    _this->_internal_set_step_id(from._internal_step_id());
  }
  if (from._internal_num_bytes() != 0) {
    _this->_internal_set_num_bytes(from._internal_num_bytes());
  }
  if (from._internal_buf_ptr() != 0) {
    _this->_internal_set_buf_ptr(from._internal_buf_ptr());
  }
  if (from._internal_request_id() != 0) {
    _this->_internal_set_request_id(from._internal_request_id());
  }
  if (from._internal_src_incarnation() != 0) {
    _this->_internal_set_src_incarnation(from._internal_src_incarnation());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RecvBufRequest::CopyFrom(const RecvBufRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RecvBufRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvBufRequest::IsInitialized() const {
  return true;
}

void RecvBufRequest::InternalSwap(RecvBufRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.buf_rendezvous_key_, lhs_arena,
      &other->_impl_.buf_rendezvous_key_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.src_device_, lhs_arena,
      &other->_impl_.src_device_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.dst_device_, lhs_arena,
      &other->_impl_.dst_device_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RecvBufRequest, _impl_.src_incarnation_)
      + sizeof(RecvBufRequest::_impl_.src_incarnation_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RecvBufRequest, _impl_.client_locality_)>(
          reinterpret_cast<char*>(&_impl_.client_locality_),
          reinterpret_cast<char*>(&other->_impl_.client_locality_));
}

std::string RecvBufRequest::GetTypeName() const {
  return "tensorflow.RecvBufRequest";
}


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

class RecvBufResponse::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Any& transport_options(const RecvBufResponse* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Any&
RecvBufResponse::_Internal::transport_options(const RecvBufResponse* msg) {
  return *msg->_impl_.transport_options_;
}
void RecvBufResponse::clear_transport_options() {
  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
}
RecvBufResponse::RecvBufResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.RecvBufResponse)
}
RecvBufResponse::RecvBufResponse(const RecvBufResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  RecvBufResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.buf_ptr_){}
    , decltype(_impl_.num_bytes_){}
    , decltype(_impl_.send_start_micros_){}
    , decltype(_impl_.is_dead_){}
    , decltype(_impl_.require_ack_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_transport_options()) {
    _this->_impl_.transport_options_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from._impl_.transport_options_);
  }
  ::memcpy(&_impl_.buf_ptr_, &from._impl_.buf_ptr_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.require_ack_) -
    reinterpret_cast<char*>(&_impl_.buf_ptr_)) + sizeof(_impl_.require_ack_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.RecvBufResponse)
}

inline void RecvBufResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.transport_options_){nullptr}
    , decltype(_impl_.buf_ptr_){::uint64_t{0u}}
    , decltype(_impl_.num_bytes_){::int64_t{0}}
    , decltype(_impl_.send_start_micros_){::int64_t{0}}
    , decltype(_impl_.is_dead_){false}
    , decltype(_impl_.require_ack_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

RecvBufResponse::~RecvBufResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.RecvBufResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void RecvBufResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.transport_options_;
}

void RecvBufResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void RecvBufResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.RecvBufResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.transport_options_ != nullptr) {
    delete _impl_.transport_options_;
  }
  _impl_.transport_options_ = nullptr;
  ::memset(&_impl_.buf_ptr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.require_ack_) -
      reinterpret_cast<char*>(&_impl_.buf_ptr_)) + sizeof(_impl_.require_ack_));
  _internal_metadata_.Clear<std::string>();
}

const char* RecvBufResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // fixed64 buf_ptr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
          _impl_.buf_ptr_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
          ptr += sizeof(::uint64_t);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 num_bytes = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.num_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_dead = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.is_dead_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Any transport_options = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_transport_options(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 send_start_micros = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.send_start_micros_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool require_ack = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.require_ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* RecvBufResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RecvBufResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // fixed64 buf_ptr = 1;
  if (this->_internal_buf_ptr() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_buf_ptr(), target);
  }

  // int64 num_bytes = 2;
  if (this->_internal_num_bytes() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_num_bytes(), target);
  }

  // bool is_dead = 3;
  if (this->_internal_is_dead() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_dead(), target);
  }

  // .google.protobuf.Any transport_options = 4;
  if (this->_internal_has_transport_options()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::transport_options(this),
        _Internal::transport_options(this).GetCachedSize(), target, stream);
  }

  // int64 send_start_micros = 5;
  if (this->_internal_send_start_micros() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_send_start_micros(), target);
  }

  // bool require_ack = 6;
  if (this->_internal_require_ack() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_require_ack(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RecvBufResponse)
  return target;
}

size_t RecvBufResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.RecvBufResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .google.protobuf.Any transport_options = 4;
  if (this->_internal_has_transport_options()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.transport_options_);
  }

  // fixed64 buf_ptr = 1;
  if (this->_internal_buf_ptr() != 0) {
    total_size += 1 + 8;
  }

  // int64 num_bytes = 2;
  if (this->_internal_num_bytes() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_num_bytes());
  }

  // int64 send_start_micros = 5;
  if (this->_internal_send_start_micros() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_send_start_micros());
  }

  // bool is_dead = 3;
  if (this->_internal_is_dead() != 0) {
    total_size += 1 + 1;
  }

  // bool require_ack = 6;
  if (this->_internal_require_ack() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RecvBufResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const RecvBufResponse*>(
      &from));
}

void RecvBufResponse::MergeFrom(const RecvBufResponse& from) {
  RecvBufResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RecvBufResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_transport_options()) {
    _this->_internal_mutable_transport_options()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(
        from._internal_transport_options());
  }
  if (from._internal_buf_ptr() != 0) {
    _this->_internal_set_buf_ptr(from._internal_buf_ptr());
  }
  if (from._internal_num_bytes() != 0) {
    _this->_internal_set_num_bytes(from._internal_num_bytes());
  }
  if (from._internal_send_start_micros() != 0) {
    _this->_internal_set_send_start_micros(from._internal_send_start_micros());
  }
  if (from._internal_is_dead() != 0) {
    _this->_internal_set_is_dead(from._internal_is_dead());
  }
  if (from._internal_require_ack() != 0) {
    _this->_internal_set_require_ack(from._internal_require_ack());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void RecvBufResponse::CopyFrom(const RecvBufResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RecvBufResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvBufResponse::IsInitialized() const {
  return true;
}

void RecvBufResponse::InternalSwap(RecvBufResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RecvBufResponse, _impl_.require_ack_)
      + sizeof(RecvBufResponse::_impl_.require_ack_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(RecvBufResponse, _impl_.transport_options_)>(
          reinterpret_cast<char*>(&_impl_.transport_options_),
          reinterpret_cast<char*>(&other->_impl_.transport_options_));
}

std::string RecvBufResponse::GetTypeName() const {
  return "tensorflow.RecvBufResponse";
}


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

class CompleteGroupRequest::_Internal {
 public:
  static const ::tensorflow::DeviceAttributes& device_attributes(const CompleteGroupRequest* msg);
};

const ::tensorflow::DeviceAttributes&
CompleteGroupRequest::_Internal::device_attributes(const CompleteGroupRequest* msg) {
  return *msg->_impl_.device_attributes_;
}
void CompleteGroupRequest::clear_device_attributes() {
  if (GetArenaForAllocation() == nullptr && _impl_.device_attributes_ != nullptr) {
    delete _impl_.device_attributes_;
  }
  _impl_.device_attributes_ = nullptr;
}
CompleteGroupRequest::CompleteGroupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CompleteGroupRequest)
}
CompleteGroupRequest::CompleteGroupRequest(const CompleteGroupRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CompleteGroupRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.device_type_){}
    , decltype(_impl_.device_attributes_){nullptr}
    , decltype(_impl_.group_key_){}
    , decltype(_impl_.group_size_){}
    , decltype(_impl_.collective_type_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_device_type().empty()) {
    _this->_impl_.device_type_.Set(from._internal_device_type(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_device_attributes()) {
    _this->_impl_.device_attributes_ = new ::tensorflow::DeviceAttributes(*from._impl_.device_attributes_);
  }
  ::memcpy(&_impl_.group_key_, &from._impl_.group_key_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.collective_type_) -
    reinterpret_cast<char*>(&_impl_.group_key_)) + sizeof(_impl_.collective_type_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.CompleteGroupRequest)
}

inline void CompleteGroupRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.device_type_){}
    , decltype(_impl_.device_attributes_){nullptr}
    , decltype(_impl_.group_key_){0}
    , decltype(_impl_.group_size_){0}
    , decltype(_impl_.collective_type_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CompleteGroupRequest::~CompleteGroupRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.CompleteGroupRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CompleteGroupRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.device_type_.Destroy();
  if (this != internal_default_instance()) delete _impl_.device_attributes_;
}

void CompleteGroupRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CompleteGroupRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CompleteGroupRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.device_type_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.device_attributes_ != nullptr) {
    delete _impl_.device_attributes_;
  }
  _impl_.device_attributes_ = nullptr;
  ::memset(&_impl_.group_key_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.collective_type_) -
      reinterpret_cast<char*>(&_impl_.group_key_)) + sizeof(_impl_.collective_type_));
  _internal_metadata_.Clear<std::string>();
}

const char* CompleteGroupRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 group_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.group_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 group_size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.group_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string device_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_device_type();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 collective_type = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.collective_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DeviceAttributes device_attributes = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_device_attributes(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CompleteGroupRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CompleteGroupRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 group_key = 1;
  if (this->_internal_group_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_group_key(), target);
  }

  // int32 group_size = 2;
  if (this->_internal_group_size() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_group_size(), target);
  }

  // string device_type = 3;
  if (!this->_internal_device_type().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_device_type().data(), static_cast<int>(this->_internal_device_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CompleteGroupRequest.device_type");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_device_type(), target);
  }

  // int32 collective_type = 5;
  if (this->_internal_collective_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_collective_type(), target);
  }

  // .tensorflow.DeviceAttributes device_attributes = 6;
  if (this->_internal_has_device_attributes()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::device_attributes(this),
        _Internal::device_attributes(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CompleteGroupRequest)
  return target;
}

size_t CompleteGroupRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CompleteGroupRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string device_type = 3;
  if (!this->_internal_device_type().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_device_type());
  }

  // .tensorflow.DeviceAttributes device_attributes = 6;
  if (this->_internal_has_device_attributes()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.device_attributes_);
  }

  // int32 group_key = 1;
  if (this->_internal_group_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_key());
  }

  // int32 group_size = 2;
  if (this->_internal_group_size() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_size());
  }

  // int32 collective_type = 5;
  if (this->_internal_collective_type() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_collective_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CompleteGroupRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CompleteGroupRequest*>(
      &from));
}

void CompleteGroupRequest::MergeFrom(const CompleteGroupRequest& from) {
  CompleteGroupRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CompleteGroupRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_device_type().empty()) {
    _this->_internal_set_device_type(from._internal_device_type());
  }
  if (from._internal_has_device_attributes()) {
    _this->_internal_mutable_device_attributes()->::tensorflow::DeviceAttributes::MergeFrom(
        from._internal_device_attributes());
  }
  if (from._internal_group_key() != 0) {
    _this->_internal_set_group_key(from._internal_group_key());
  }
  if (from._internal_group_size() != 0) {
    _this->_internal_set_group_size(from._internal_group_size());
  }
  if (from._internal_collective_type() != 0) {
    _this->_internal_set_collective_type(from._internal_collective_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CompleteGroupRequest::CopyFrom(const CompleteGroupRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CompleteGroupRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CompleteGroupRequest::IsInitialized() const {
  return true;
}

void CompleteGroupRequest::InternalSwap(CompleteGroupRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.device_type_, lhs_arena,
      &other->_impl_.device_type_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CompleteGroupRequest, _impl_.collective_type_)
      + sizeof(CompleteGroupRequest::_impl_.collective_type_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(CompleteGroupRequest, _impl_.device_attributes_)>(
          reinterpret_cast<char*>(&_impl_.device_attributes_),
          reinterpret_cast<char*>(&other->_impl_.device_attributes_));
}

std::string CompleteGroupRequest::GetTypeName() const {
  return "tensorflow.CompleteGroupRequest";
}


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

class CompleteGroupResponse::_Internal {
 public:
};

void CompleteGroupResponse::clear_device_attributes() {
  _impl_.device_attributes_.Clear();
}
CompleteGroupResponse::CompleteGroupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CompleteGroupResponse)
}
CompleteGroupResponse::CompleteGroupResponse(const CompleteGroupResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CompleteGroupResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.device_attributes_){from._impl_.device_attributes_}
    , decltype(_impl_.device_type_){}
    , decltype(_impl_.communicator_key_){}
    , decltype(_impl_.group_key_){}
    , decltype(_impl_.group_size_){}
    , decltype(_impl_.num_tasks_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_device_type().empty()) {
    _this->_impl_.device_type_.Set(from._internal_device_type(),
      _this->GetArenaForAllocation());
  }
  _impl_.communicator_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.communicator_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_communicator_key().empty()) {
    _this->_impl_.communicator_key_.Set(from._internal_communicator_key(),
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.group_key_, &from._impl_.group_key_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.num_tasks_) -
    reinterpret_cast<char*>(&_impl_.group_key_)) + sizeof(_impl_.num_tasks_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.CompleteGroupResponse)
}

inline void CompleteGroupResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.device_attributes_){arena}
    , decltype(_impl_.device_type_){}
    , decltype(_impl_.communicator_key_){}
    , decltype(_impl_.group_key_){0}
    , decltype(_impl_.group_size_){0}
    , decltype(_impl_.num_tasks_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.communicator_key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.communicator_key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CompleteGroupResponse::~CompleteGroupResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.CompleteGroupResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CompleteGroupResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.device_attributes_.~RepeatedPtrField();
  _impl_.device_type_.Destroy();
  _impl_.communicator_key_.Destroy();
}

void CompleteGroupResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CompleteGroupResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CompleteGroupResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.device_attributes_.Clear();
  _impl_.device_type_.ClearToEmpty();
  _impl_.communicator_key_.ClearToEmpty();
  ::memset(&_impl_.group_key_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.num_tasks_) -
      reinterpret_cast<char*>(&_impl_.group_key_)) + sizeof(_impl_.num_tasks_));
  _internal_metadata_.Clear<std::string>();
}

const char* CompleteGroupResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 group_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.group_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 group_size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.group_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string device_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_device_type();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 num_tasks = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.num_tasks_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bytes communicator_key = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          auto str = _internal_mutable_communicator_key();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .tensorflow.DeviceAttributes device_attributes = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_device_attributes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CompleteGroupResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CompleteGroupResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 group_key = 1;
  if (this->_internal_group_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_group_key(), target);
  }

  // int32 group_size = 2;
  if (this->_internal_group_size() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_group_size(), target);
  }

  // string device_type = 3;
  if (!this->_internal_device_type().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_device_type().data(), static_cast<int>(this->_internal_device_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CompleteGroupResponse.device_type");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_device_type(), target);
  }

  // int32 num_tasks = 4;
  if (this->_internal_num_tasks() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_num_tasks(), target);
  }

  // bytes communicator_key = 7;
  if (!this->_internal_communicator_key().empty()) {
    target = stream->WriteBytesMaybeAliased(
        7, this->_internal_communicator_key(), target);
  }

  // repeated .tensorflow.DeviceAttributes device_attributes = 8;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_device_attributes_size()); i < n; i++) {
    const auto& repfield = this->_internal_device_attributes(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CompleteGroupResponse)
  return target;
}

size_t CompleteGroupResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CompleteGroupResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.DeviceAttributes device_attributes = 8;
  total_size += 1UL * this->_internal_device_attributes_size();
  for (const auto& msg : this->_impl_.device_attributes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string device_type = 3;
  if (!this->_internal_device_type().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_device_type());
  }

  // bytes communicator_key = 7;
  if (!this->_internal_communicator_key().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_communicator_key());
  }

  // int32 group_key = 1;
  if (this->_internal_group_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_key());
  }

  // int32 group_size = 2;
  if (this->_internal_group_size() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_size());
  }

  // int32 num_tasks = 4;
  if (this->_internal_num_tasks() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_tasks());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CompleteGroupResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CompleteGroupResponse*>(
      &from));
}

void CompleteGroupResponse::MergeFrom(const CompleteGroupResponse& from) {
  CompleteGroupResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CompleteGroupResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.device_attributes_.MergeFrom(from._impl_.device_attributes_);
  if (!from._internal_device_type().empty()) {
    _this->_internal_set_device_type(from._internal_device_type());
  }
  if (!from._internal_communicator_key().empty()) {
    _this->_internal_set_communicator_key(from._internal_communicator_key());
  }
  if (from._internal_group_key() != 0) {
    _this->_internal_set_group_key(from._internal_group_key());
  }
  if (from._internal_group_size() != 0) {
    _this->_internal_set_group_size(from._internal_group_size());
  }
  if (from._internal_num_tasks() != 0) {
    _this->_internal_set_num_tasks(from._internal_num_tasks());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CompleteGroupResponse::CopyFrom(const CompleteGroupResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CompleteGroupResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CompleteGroupResponse::IsInitialized() const {
  return true;
}

void CompleteGroupResponse::InternalSwap(CompleteGroupResponse* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.device_attributes_.InternalSwap(&other->_impl_.device_attributes_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.device_type_, lhs_arena,
      &other->_impl_.device_type_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.communicator_key_, lhs_arena,
      &other->_impl_.communicator_key_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CompleteGroupResponse, _impl_.num_tasks_)
      + sizeof(CompleteGroupResponse::_impl_.num_tasks_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(CompleteGroupResponse, _impl_.group_key_)>(
          reinterpret_cast<char*>(&_impl_.group_key_),
          reinterpret_cast<char*>(&other->_impl_.group_key_));
}

std::string CompleteGroupResponse::GetTypeName() const {
  return "tensorflow.CompleteGroupResponse";
}


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

class CompleteInstanceRequest::_Internal {
 public:
  static const ::tensorflow::TensorShapeProto& shape(const CompleteInstanceRequest* msg);
};

const ::tensorflow::TensorShapeProto&
CompleteInstanceRequest::_Internal::shape(const CompleteInstanceRequest* msg) {
  return *msg->_impl_.shape_;
}
void CompleteInstanceRequest::clear_shape() {
  if (GetArenaForAllocation() == nullptr && _impl_.shape_ != nullptr) {
    delete _impl_.shape_;
  }
  _impl_.shape_ = nullptr;
}
CompleteInstanceRequest::CompleteInstanceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CompleteInstanceRequest)
}
CompleteInstanceRequest::CompleteInstanceRequest(const CompleteInstanceRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CompleteInstanceRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.subdiv_offset_){from._impl_.subdiv_offset_}
    , /*decltype(_impl_._subdiv_offset_cached_byte_size_)*/{0}
    , decltype(_impl_.name_){}
    , decltype(_impl_.device_type_){}
    , decltype(_impl_.device_){}
    , decltype(_impl_.shape_){nullptr}
    , decltype(_impl_.type_){}
    , decltype(_impl_.data_type_){}
    , decltype(_impl_.group_key_){}
    , decltype(_impl_.group_size_){}
    , decltype(_impl_.instance_key_){}
    , decltype(_impl_.is_source_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_name().empty()) {
    _this->_impl_.name_.Set(from._internal_name(),
      _this->GetArenaForAllocation());
  }
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_device_type().empty()) {
    _this->_impl_.device_type_.Set(from._internal_device_type(),
      _this->GetArenaForAllocation());
  }
  _impl_.device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_device().empty()) {
    _this->_impl_.device_.Set(from._internal_device(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_shape()) {
    _this->_impl_.shape_ = new ::tensorflow::TensorShapeProto(*from._impl_.shape_);
  }
  ::memcpy(&_impl_.type_, &from._impl_.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_source_) -
    reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.is_source_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.CompleteInstanceRequest)
}

inline void CompleteInstanceRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.subdiv_offset_){arena}
    , /*decltype(_impl_._subdiv_offset_cached_byte_size_)*/{0}
    , decltype(_impl_.name_){}
    , decltype(_impl_.device_type_){}
    , decltype(_impl_.device_){}
    , decltype(_impl_.shape_){nullptr}
    , decltype(_impl_.type_){0}
    , decltype(_impl_.data_type_){0}
    , decltype(_impl_.group_key_){0}
    , decltype(_impl_.group_size_){0}
    , decltype(_impl_.instance_key_){0}
    , decltype(_impl_.is_source_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.device_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.device_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.device_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CompleteInstanceRequest::~CompleteInstanceRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.CompleteInstanceRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CompleteInstanceRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.subdiv_offset_.~RepeatedField();
  _impl_.name_.Destroy();
  _impl_.device_type_.Destroy();
  _impl_.device_.Destroy();
  if (this != internal_default_instance()) delete _impl_.shape_;
}

void CompleteInstanceRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CompleteInstanceRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CompleteInstanceRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.subdiv_offset_.Clear();
  _impl_.name_.ClearToEmpty();
  _impl_.device_type_.ClearToEmpty();
  _impl_.device_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.shape_ != nullptr) {
    delete _impl_.shape_;
  }
  _impl_.shape_ = nullptr;
  ::memset(&_impl_.type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.is_source_) -
      reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.is_source_));
  _internal_metadata_.Clear<std::string>();
}

const char* CompleteInstanceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.DataType data_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_data_type(static_cast<::tensorflow::DataType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .tensorflow.TensorShapeProto shape = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 group_key = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.group_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 group_size = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.group_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 instance_key = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          _impl_.instance_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string device_type = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          auto str = _internal_mutable_device_type();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 subdiv_offset = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_subdiv_offset(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 72) {
          _internal_add_subdiv_offset(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string device = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
          auto str = _internal_mutable_device();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_source = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
          _impl_.is_source_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CompleteInstanceRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CompleteInstanceRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1;
  if (!this->_internal_name().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CompleteInstanceRequest.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // int32 type = 2;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_type(), target);
  }

  // .tensorflow.DataType data_type = 3;
  if (this->_internal_data_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      3, this->_internal_data_type(), target);
  }

  // .tensorflow.TensorShapeProto shape = 4;
  if (this->_internal_has_shape()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::shape(this),
        _Internal::shape(this).GetCachedSize(), target, stream);
  }

  // int32 group_key = 5;
  if (this->_internal_group_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_group_key(), target);
  }

  // int32 group_size = 6;
  if (this->_internal_group_size() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_group_size(), target);
  }

  // int32 instance_key = 7;
  if (this->_internal_instance_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_instance_key(), target);
  }

  // string device_type = 8;
  if (!this->_internal_device_type().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_device_type().data(), static_cast<int>(this->_internal_device_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CompleteInstanceRequest.device_type");
    target = stream->WriteStringMaybeAliased(
        8, this->_internal_device_type(), target);
  }

  // repeated int32 subdiv_offset = 9;
  {
    int byte_size = _impl_._subdiv_offset_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(
          9, _internal_subdiv_offset(), byte_size, target);
    }
  }

  // string device = 10;
  if (!this->_internal_device().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_device().data(), static_cast<int>(this->_internal_device().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "tensorflow.CompleteInstanceRequest.device");
    target = stream->WriteStringMaybeAliased(
        10, this->_internal_device(), target);
  }

  // bool is_source = 11;
  if (this->_internal_is_source() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_is_source(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CompleteInstanceRequest)
  return target;
}

size_t CompleteInstanceRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CompleteInstanceRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 subdiv_offset = 9;
  {
    size_t data_size = ::_pbi::WireFormatLite::
      Int32Size(this->_impl_.subdiv_offset_);
    if (data_size > 0) {
      total_size += 1 +
        ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
    }
    int cached_size = ::_pbi::ToCachedSize(data_size);
    _impl_._subdiv_offset_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // string name = 1;
  if (!this->_internal_name().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());
  }

  // string device_type = 8;
  if (!this->_internal_device_type().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_device_type());
  }

  // string device = 10;
  if (!this->_internal_device().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_device());
  }

  // .tensorflow.TensorShapeProto shape = 4;
  if (this->_internal_has_shape()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.shape_);
  }

  // int32 type = 2;
  if (this->_internal_type() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_type());
  }

  // .tensorflow.DataType data_type = 3;
  if (this->_internal_data_type() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_data_type());
  }

  // int32 group_key = 5;
  if (this->_internal_group_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_key());
  }

  // int32 group_size = 6;
  if (this->_internal_group_size() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group_size());
  }

  // int32 instance_key = 7;
  if (this->_internal_instance_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_instance_key());
  }

  // bool is_source = 11;
  if (this->_internal_is_source() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CompleteInstanceRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CompleteInstanceRequest*>(
      &from));
}

void CompleteInstanceRequest::MergeFrom(const CompleteInstanceRequest& from) {
  CompleteInstanceRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CompleteInstanceRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.subdiv_offset_.MergeFrom(from._impl_.subdiv_offset_);
  if (!from._internal_name().empty()) {
    _this->_internal_set_name(from._internal_name());
  }
  if (!from._internal_device_type().empty()) {
    _this->_internal_set_device_type(from._internal_device_type());
  }
  if (!from._internal_device().empty()) {
    _this->_internal_set_device(from._internal_device());
  }
  if (from._internal_has_shape()) {
    _this->_internal_mutable_shape()->::tensorflow::TensorShapeProto::MergeFrom(
        from._internal_shape());
  }
  if (from._internal_type() != 0) {
    _this->_internal_set_type(from._internal_type());
  }
  if (from._internal_data_type() != 0) {
    _this->_internal_set_data_type(from._internal_data_type());
  }
  if (from._internal_group_key() != 0) {
    _this->_internal_set_group_key(from._internal_group_key());
  }
  if (from._internal_group_size() != 0) {
    _this->_internal_set_group_size(from._internal_group_size());
  }
  if (from._internal_instance_key() != 0) {
    _this->_internal_set_instance_key(from._internal_instance_key());
  }
  if (from._internal_is_source() != 0) {
    _this->_internal_set_is_source(from._internal_is_source());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CompleteInstanceRequest::CopyFrom(const CompleteInstanceRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CompleteInstanceRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CompleteInstanceRequest::IsInitialized() const {
  return true;
}

void CompleteInstanceRequest::InternalSwap(CompleteInstanceRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.subdiv_offset_.InternalSwap(&other->_impl_.subdiv_offset_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.name_, lhs_arena,
      &other->_impl_.name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.device_type_, lhs_arena,
      &other->_impl_.device_type_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.device_, lhs_arena,
      &other->_impl_.device_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CompleteInstanceRequest, _impl_.is_source_)
      + sizeof(CompleteInstanceRequest::_impl_.is_source_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(CompleteInstanceRequest, _impl_.shape_)>(
          reinterpret_cast<char*>(&_impl_.shape_),
          reinterpret_cast<char*>(&other->_impl_.shape_));
}

std::string CompleteInstanceRequest::GetTypeName() const {
  return "tensorflow.CompleteInstanceRequest";
}


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

class CompleteInstanceResponse::_Internal {
 public:
};

CompleteInstanceResponse::CompleteInstanceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.CompleteInstanceResponse)
}
CompleteInstanceResponse::CompleteInstanceResponse(const CompleteInstanceResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CompleteInstanceResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.instance_key_){}
    , decltype(_impl_.source_rank_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.instance_key_, &from._impl_.instance_key_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.source_rank_) -
    reinterpret_cast<char*>(&_impl_.instance_key_)) + sizeof(_impl_.source_rank_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.CompleteInstanceResponse)
}

inline void CompleteInstanceResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.instance_key_){0}
    , decltype(_impl_.source_rank_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CompleteInstanceResponse::~CompleteInstanceResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.CompleteInstanceResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CompleteInstanceResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CompleteInstanceResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CompleteInstanceResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.CompleteInstanceResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.instance_key_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.source_rank_) -
      reinterpret_cast<char*>(&_impl_.instance_key_)) + sizeof(_impl_.source_rank_));
  _internal_metadata_.Clear<std::string>();
}

const char* CompleteInstanceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 instance_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.instance_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 source_rank = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.source_rank_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CompleteInstanceResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CompleteInstanceResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 instance_key = 1;
  if (this->_internal_instance_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_instance_key(), target);
  }

  // int32 source_rank = 2;
  if (this->_internal_source_rank() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_source_rank(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CompleteInstanceResponse)
  return target;
}

size_t CompleteInstanceResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.CompleteInstanceResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 instance_key = 1;
  if (this->_internal_instance_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_instance_key());
  }

  // int32 source_rank = 2;
  if (this->_internal_source_rank() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_source_rank());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CompleteInstanceResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CompleteInstanceResponse*>(
      &from));
}

void CompleteInstanceResponse::MergeFrom(const CompleteInstanceResponse& from) {
  CompleteInstanceResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CompleteInstanceResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_instance_key() != 0) {
    _this->_internal_set_instance_key(from._internal_instance_key());
  }
  if (from._internal_source_rank() != 0) {
    _this->_internal_set_source_rank(from._internal_source_rank());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CompleteInstanceResponse::CopyFrom(const CompleteInstanceResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CompleteInstanceResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CompleteInstanceResponse::IsInitialized() const {
  return true;
}

void CompleteInstanceResponse::InternalSwap(CompleteInstanceResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CompleteInstanceResponse, _impl_.source_rank_)
      + sizeof(CompleteInstanceResponse::_impl_.source_rank_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(CompleteInstanceResponse, _impl_.instance_key_)>(
          reinterpret_cast<char*>(&_impl_.instance_key_),
          reinterpret_cast<char*>(&other->_impl_.instance_key_));
}

std::string CompleteInstanceResponse::GetTypeName() const {
  return "tensorflow.CompleteInstanceResponse";
}


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

class GetStepSequenceRequest::_Internal {
 public:
};

GetStepSequenceRequest::GetStepSequenceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.GetStepSequenceRequest)
}
GetStepSequenceRequest::GetStepSequenceRequest(const GetStepSequenceRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetStepSequenceRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_key_){from._impl_.graph_key_}
    , /*decltype(_impl_._graph_key_cached_byte_size_)*/{0}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.GetStepSequenceRequest)
}

inline void GetStepSequenceRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_key_){arena}
    , /*decltype(_impl_._graph_key_cached_byte_size_)*/{0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

GetStepSequenceRequest::~GetStepSequenceRequest() {
  // @@protoc_insertion_point(destructor:tensorflow.GetStepSequenceRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetStepSequenceRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.graph_key_.~RepeatedField();
}

void GetStepSequenceRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetStepSequenceRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.GetStepSequenceRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.graph_key_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetStepSequenceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int64 graph_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_graph_key(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_graph_key(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetStepSequenceRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetStepSequenceRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int64 graph_key = 1;
  {
    int byte_size = _impl_._graph_key_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(
          1, _internal_graph_key(), byte_size, target);
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetStepSequenceRequest)
  return target;
}

size_t GetStepSequenceRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.GetStepSequenceRequest)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int64 graph_key = 1;
  {
    size_t data_size = ::_pbi::WireFormatLite::
      Int64Size(this->_impl_.graph_key_);
    if (data_size > 0) {
      total_size += 1 +
        ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
    }
    int cached_size = ::_pbi::ToCachedSize(data_size);
    _impl_._graph_key_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetStepSequenceRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetStepSequenceRequest*>(
      &from));
}

void GetStepSequenceRequest::MergeFrom(const GetStepSequenceRequest& from) {
  GetStepSequenceRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetStepSequenceRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.graph_key_.MergeFrom(from._impl_.graph_key_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetStepSequenceRequest::CopyFrom(const GetStepSequenceRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetStepSequenceRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetStepSequenceRequest::IsInitialized() const {
  return true;
}

void GetStepSequenceRequest::InternalSwap(GetStepSequenceRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.graph_key_.InternalSwap(&other->_impl_.graph_key_);
}

std::string GetStepSequenceRequest::GetTypeName() const {
  return "tensorflow.GetStepSequenceRequest";
}


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

class StepSequence::_Internal {
 public:
};

StepSequence::StepSequence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.StepSequence)
}
StepSequence::StepSequence(const StepSequence& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StepSequence* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_key_){}
    , decltype(_impl_.next_step_id_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.graph_key_, &from._impl_.graph_key_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.next_step_id_) -
    reinterpret_cast<char*>(&_impl_.graph_key_)) + sizeof(_impl_.next_step_id_));
  // @@protoc_insertion_point(copy_constructor:tensorflow.StepSequence)
}

inline void StepSequence::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.graph_key_){::int64_t{0}}
    , decltype(_impl_.next_step_id_){::int64_t{0}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

StepSequence::~StepSequence() {
  // @@protoc_insertion_point(destructor:tensorflow.StepSequence)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StepSequence::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void StepSequence::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StepSequence::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.StepSequence)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.graph_key_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.next_step_id_) -
      reinterpret_cast<char*>(&_impl_.graph_key_)) + sizeof(_impl_.next_step_id_));
  _internal_metadata_.Clear<std::string>();
}

const char* StepSequence::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 graph_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.graph_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 next_step_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.next_step_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* StepSequence::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.StepSequence)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 graph_key = 1;
  if (this->_internal_graph_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_graph_key(), target);
  }

  // int64 next_step_id = 2;
  if (this->_internal_next_step_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_next_step_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.StepSequence)
  return target;
}

size_t StepSequence::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.StepSequence)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int64 graph_key = 1;
  if (this->_internal_graph_key() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_graph_key());
  }

  // int64 next_step_id = 2;
  if (this->_internal_next_step_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_next_step_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StepSequence::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StepSequence*>(
      &from));
}

void StepSequence::MergeFrom(const StepSequence& from) {
  StepSequence* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.StepSequence)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_graph_key() != 0) {
    _this->_internal_set_graph_key(from._internal_graph_key());
  }
  if (from._internal_next_step_id() != 0) {
    _this->_internal_set_next_step_id(from._internal_next_step_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StepSequence::CopyFrom(const StepSequence& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.StepSequence)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StepSequence::IsInitialized() const {
  return true;
}

void StepSequence::InternalSwap(StepSequence* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(StepSequence, _impl_.next_step_id_)
      + sizeof(StepSequence::_impl_.next_step_id_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(StepSequence, _impl_.graph_key_)>(
          reinterpret_cast<char*>(&_impl_.graph_key_),
          reinterpret_cast<char*>(&other->_impl_.graph_key_));
}

std::string StepSequence::GetTypeName() const {
  return "tensorflow.StepSequence";
}


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

class GetStepSequenceResponse::_Internal {
 public:
};

GetStepSequenceResponse::GetStepSequenceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:tensorflow.GetStepSequenceResponse)
}
GetStepSequenceResponse::GetStepSequenceResponse(const GetStepSequenceResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetStepSequenceResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.step_sequence_){from._impl_.step_sequence_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:tensorflow.GetStepSequenceResponse)
}

inline void GetStepSequenceResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.step_sequence_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

GetStepSequenceResponse::~GetStepSequenceResponse() {
  // @@protoc_insertion_point(destructor:tensorflow.GetStepSequenceResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetStepSequenceResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.step_sequence_.~RepeatedPtrField();
}

void GetStepSequenceResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetStepSequenceResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:tensorflow.GetStepSequenceResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.step_sequence_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetStepSequenceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .tensorflow.StepSequence step_sequence = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_step_sequence(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetStepSequenceResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetStepSequenceResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .tensorflow.StepSequence step_sequence = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_step_sequence_size()); i < n; i++) {
    const auto& repfield = this->_internal_step_sequence(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetStepSequenceResponse)
  return target;
}

size_t GetStepSequenceResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:tensorflow.GetStepSequenceResponse)
  size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .tensorflow.StepSequence step_sequence = 1;
  total_size += 1UL * this->_internal_step_sequence_size();
  for (const auto& msg : this->_impl_.step_sequence_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetStepSequenceResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetStepSequenceResponse*>(
      &from));
}

void GetStepSequenceResponse::MergeFrom(const GetStepSequenceResponse& from) {
  GetStepSequenceResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetStepSequenceResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.step_sequence_.MergeFrom(from._impl_.step_sequence_);
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetStepSequenceResponse::CopyFrom(const GetStepSequenceResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetStepSequenceResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetStepSequenceResponse::IsInitialized() const {
  return true;
}

void GetStepSequenceResponse::InternalSwap(GetStepSequenceResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.step_sequence_.InternalSwap(&other->_impl_.step_sequence_);
}

std::string GetStepSequenceResponse::GetTypeName() const {
  return "tensorflow.GetStepSequenceResponse";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace tensorflow
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::tensorflow::GetStatusRequest*
Arena::CreateMaybeMessage< ::tensorflow::GetStatusRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::GetStatusRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::GetStatusResponse*
Arena::CreateMaybeMessage< ::tensorflow::GetStatusResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::GetStatusResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CreateWorkerSessionRequest*
Arena::CreateMaybeMessage< ::tensorflow::CreateWorkerSessionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CreateWorkerSessionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CreateWorkerSessionResponse*
Arena::CreateMaybeMessage< ::tensorflow::CreateWorkerSessionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CreateWorkerSessionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::DeleteWorkerSessionRequest*
Arena::CreateMaybeMessage< ::tensorflow::DeleteWorkerSessionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::DeleteWorkerSessionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::DeleteWorkerSessionResponse*
Arena::CreateMaybeMessage< ::tensorflow::DeleteWorkerSessionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::DeleteWorkerSessionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RegisterGraphRequest*
Arena::CreateMaybeMessage< ::tensorflow::RegisterGraphRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RegisterGraphRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RegisterGraphResponse*
Arena::CreateMaybeMessage< ::tensorflow::RegisterGraphResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RegisterGraphResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::DeregisterGraphRequest*
Arena::CreateMaybeMessage< ::tensorflow::DeregisterGraphRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::DeregisterGraphRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::DeregisterGraphResponse*
Arena::CreateMaybeMessage< ::tensorflow::DeregisterGraphResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::DeregisterGraphResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CleanupAllRequest*
Arena::CreateMaybeMessage< ::tensorflow::CleanupAllRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CleanupAllRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CleanupAllResponse*
Arena::CreateMaybeMessage< ::tensorflow::CleanupAllResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CleanupAllResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::ExecutorOpts*
Arena::CreateMaybeMessage< ::tensorflow::ExecutorOpts >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::ExecutorOpts >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RunGraphRequest*
Arena::CreateMaybeMessage< ::tensorflow::RunGraphRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RunGraphRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RunGraphResponse*
Arena::CreateMaybeMessage< ::tensorflow::RunGraphResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RunGraphResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CleanupGraphRequest*
Arena::CreateMaybeMessage< ::tensorflow::CleanupGraphRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CleanupGraphRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CleanupGraphResponse*
Arena::CreateMaybeMessage< ::tensorflow::CleanupGraphResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CleanupGraphResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RecvTensorRequest*
Arena::CreateMaybeMessage< ::tensorflow::RecvTensorRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RecvTensorRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RecvTensorResponse*
Arena::CreateMaybeMessage< ::tensorflow::RecvTensorResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RecvTensorResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::MarkRecvFinishedRequest*
Arena::CreateMaybeMessage< ::tensorflow::MarkRecvFinishedRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::MarkRecvFinishedRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::MarkRecvFinishedResponse*
Arena::CreateMaybeMessage< ::tensorflow::MarkRecvFinishedResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::MarkRecvFinishedResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::LoggingRequest*
Arena::CreateMaybeMessage< ::tensorflow::LoggingRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::LoggingRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::LabeledStepStats*
Arena::CreateMaybeMessage< ::tensorflow::LabeledStepStats >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::LabeledStepStats >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::LoggingResponse*
Arena::CreateMaybeMessage< ::tensorflow::LoggingResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::LoggingResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::TraceOpts*
Arena::CreateMaybeMessage< ::tensorflow::TraceOpts >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::TraceOpts >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::TracingRequest*
Arena::CreateMaybeMessage< ::tensorflow::TracingRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::TracingRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::TracingResponse*
Arena::CreateMaybeMessage< ::tensorflow::TracingResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::TracingResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RecvBufRequest*
Arena::CreateMaybeMessage< ::tensorflow::RecvBufRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RecvBufRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::RecvBufResponse*
Arena::CreateMaybeMessage< ::tensorflow::RecvBufResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::RecvBufResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CompleteGroupRequest*
Arena::CreateMaybeMessage< ::tensorflow::CompleteGroupRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CompleteGroupRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CompleteGroupResponse*
Arena::CreateMaybeMessage< ::tensorflow::CompleteGroupResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CompleteGroupResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CompleteInstanceRequest*
Arena::CreateMaybeMessage< ::tensorflow::CompleteInstanceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CompleteInstanceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::CompleteInstanceResponse*
Arena::CreateMaybeMessage< ::tensorflow::CompleteInstanceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::CompleteInstanceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::GetStepSequenceRequest*
Arena::CreateMaybeMessage< ::tensorflow::GetStepSequenceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::GetStepSequenceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::StepSequence*
Arena::CreateMaybeMessage< ::tensorflow::StepSequence >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::StepSequence >(arena);
}
template<> PROTOBUF_NOINLINE ::tensorflow::GetStepSequenceResponse*
Arena::CreateMaybeMessage< ::tensorflow::GetStepSequenceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::tensorflow::GetStepSequenceResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>