// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: rpc_messages.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_rpc_5fmessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_rpc_5fmessages_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_rpc_5fmessages_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[64]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_rpc_5fmessages_2eproto;
class call_packet_info;
class call_packet_infoDefaultTypeInternal;
extern call_packet_infoDefaultTypeInternal _call_packet_info_default_instance_;
class ddr_mem_msg;
class ddr_mem_msgDefaultTypeInternal;
extern ddr_mem_msgDefaultTypeInternal _ddr_mem_msg_default_instance_;
class response_packet_info;
class response_packet_infoDefaultTypeInternal;
extern response_packet_infoDefaultTypeInternal _response_packet_info_default_instance_;
class xclAllocDeviceBuffer_call;
class xclAllocDeviceBuffer_callDefaultTypeInternal;
extern xclAllocDeviceBuffer_callDefaultTypeInternal _xclAllocDeviceBuffer_call_default_instance_;
class xclAllocDeviceBuffer_response;
class xclAllocDeviceBuffer_responseDefaultTypeInternal;
extern xclAllocDeviceBuffer_responseDefaultTypeInternal _xclAllocDeviceBuffer_response_default_instance_;
class xclClose_call;
class xclClose_callDefaultTypeInternal;
extern xclClose_callDefaultTypeInternal _xclClose_call_default_instance_;
class xclClose_response;
class xclClose_responseDefaultTypeInternal;
extern xclClose_responseDefaultTypeInternal _xclClose_response_default_instance_;
class xclCopyBO_call;
class xclCopyBO_callDefaultTypeInternal;
extern xclCopyBO_callDefaultTypeInternal _xclCopyBO_call_default_instance_;
class xclCopyBO_response;
class xclCopyBO_responseDefaultTypeInternal;
extern xclCopyBO_responseDefaultTypeInternal _xclCopyBO_response_default_instance_;
class xclCopyBufferDevice2Host_call;
class xclCopyBufferDevice2Host_callDefaultTypeInternal;
extern xclCopyBufferDevice2Host_callDefaultTypeInternal _xclCopyBufferDevice2Host_call_default_instance_;
class xclCopyBufferDevice2Host_response;
class xclCopyBufferDevice2Host_responseDefaultTypeInternal;
extern xclCopyBufferDevice2Host_responseDefaultTypeInternal _xclCopyBufferDevice2Host_response_default_instance_;
class xclCopyBufferHost2Device_call;
class xclCopyBufferHost2Device_callDefaultTypeInternal;
extern xclCopyBufferHost2Device_callDefaultTypeInternal _xclCopyBufferHost2Device_call_default_instance_;
class xclCopyBufferHost2Device_response;
class xclCopyBufferHost2Device_responseDefaultTypeInternal;
extern xclCopyBufferHost2Device_responseDefaultTypeInternal _xclCopyBufferHost2Device_response_default_instance_;
class xclCreateQueue_call;
class xclCreateQueue_callDefaultTypeInternal;
extern xclCreateQueue_callDefaultTypeInternal _xclCreateQueue_call_default_instance_;
class xclCreateQueue_response;
class xclCreateQueue_responseDefaultTypeInternal;
extern xclCreateQueue_responseDefaultTypeInternal _xclCreateQueue_response_default_instance_;
class xclDestroyQueue_call;
class xclDestroyQueue_callDefaultTypeInternal;
extern xclDestroyQueue_callDefaultTypeInternal _xclDestroyQueue_call_default_instance_;
class xclDestroyQueue_response;
class xclDestroyQueue_responseDefaultTypeInternal;
extern xclDestroyQueue_responseDefaultTypeInternal _xclDestroyQueue_response_default_instance_;
class xclFreeDeviceBuffer_call;
class xclFreeDeviceBuffer_callDefaultTypeInternal;
extern xclFreeDeviceBuffer_callDefaultTypeInternal _xclFreeDeviceBuffer_call_default_instance_;
class xclFreeDeviceBuffer_response;
class xclFreeDeviceBuffer_responseDefaultTypeInternal;
extern xclFreeDeviceBuffer_responseDefaultTypeInternal _xclFreeDeviceBuffer_response_default_instance_;
class xclGetDebugMessages_call;
class xclGetDebugMessages_callDefaultTypeInternal;
extern xclGetDebugMessages_callDefaultTypeInternal _xclGetDebugMessages_call_default_instance_;
class xclGetDebugMessages_response;
class xclGetDebugMessages_responseDefaultTypeInternal;
extern xclGetDebugMessages_responseDefaultTypeInternal _xclGetDebugMessages_response_default_instance_;
class xclGetDeviceTimestamp_call;
class xclGetDeviceTimestamp_callDefaultTypeInternal;
extern xclGetDeviceTimestamp_callDefaultTypeInternal _xclGetDeviceTimestamp_call_default_instance_;
class xclGetDeviceTimestamp_response;
class xclGetDeviceTimestamp_responseDefaultTypeInternal;
extern xclGetDeviceTimestamp_responseDefaultTypeInternal _xclGetDeviceTimestamp_response_default_instance_;
class xclImportBO_call;
class xclImportBO_callDefaultTypeInternal;
extern xclImportBO_callDefaultTypeInternal _xclImportBO_call_default_instance_;
class xclImportBO_response;
class xclImportBO_responseDefaultTypeInternal;
extern xclImportBO_responseDefaultTypeInternal _xclImportBO_response_default_instance_;
class xclLoadBitstream_call;
class xclLoadBitstream_callDefaultTypeInternal;
extern xclLoadBitstream_callDefaultTypeInternal _xclLoadBitstream_call_default_instance_;
class xclLoadBitstream_call_ddrbank;
class xclLoadBitstream_call_ddrbankDefaultTypeInternal;
extern xclLoadBitstream_call_ddrbankDefaultTypeInternal _xclLoadBitstream_call_ddrbank_default_instance_;
class xclLoadBitstream_response;
class xclLoadBitstream_responseDefaultTypeInternal;
extern xclLoadBitstream_responseDefaultTypeInternal _xclLoadBitstream_response_default_instance_;
class xclPerfMonGetTraceCount_call;
class xclPerfMonGetTraceCount_callDefaultTypeInternal;
extern xclPerfMonGetTraceCount_callDefaultTypeInternal _xclPerfMonGetTraceCount_call_default_instance_;
class xclPerfMonGetTraceCount_response;
class xclPerfMonGetTraceCount_responseDefaultTypeInternal;
extern xclPerfMonGetTraceCount_responseDefaultTypeInternal _xclPerfMonGetTraceCount_response_default_instance_;
class xclPerfMonReadCounters_Streaming_call;
class xclPerfMonReadCounters_Streaming_callDefaultTypeInternal;
extern xclPerfMonReadCounters_Streaming_callDefaultTypeInternal _xclPerfMonReadCounters_Streaming_call_default_instance_;
class xclPerfMonReadCounters_Streaming_response;
class xclPerfMonReadCounters_Streaming_responseDefaultTypeInternal;
extern xclPerfMonReadCounters_Streaming_responseDefaultTypeInternal _xclPerfMonReadCounters_Streaming_response_default_instance_;
class xclPerfMonReadCounters_call;
class xclPerfMonReadCounters_callDefaultTypeInternal;
extern xclPerfMonReadCounters_callDefaultTypeInternal _xclPerfMonReadCounters_call_default_instance_;
class xclPerfMonReadCounters_response;
class xclPerfMonReadCounters_responseDefaultTypeInternal;
extern xclPerfMonReadCounters_responseDefaultTypeInternal _xclPerfMonReadCounters_response_default_instance_;
class xclPerfMonReadTrace_Streaming_call;
class xclPerfMonReadTrace_Streaming_callDefaultTypeInternal;
extern xclPerfMonReadTrace_Streaming_callDefaultTypeInternal _xclPerfMonReadTrace_Streaming_call_default_instance_;
class xclPerfMonReadTrace_Streaming_response;
class xclPerfMonReadTrace_Streaming_responseDefaultTypeInternal;
extern xclPerfMonReadTrace_Streaming_responseDefaultTypeInternal _xclPerfMonReadTrace_Streaming_response_default_instance_;
class xclPerfMonReadTrace_Streaming_response_events;
class xclPerfMonReadTrace_Streaming_response_eventsDefaultTypeInternal;
extern xclPerfMonReadTrace_Streaming_response_eventsDefaultTypeInternal _xclPerfMonReadTrace_Streaming_response_events_default_instance_;
class xclPerfMonReadTrace_call;
class xclPerfMonReadTrace_callDefaultTypeInternal;
extern xclPerfMonReadTrace_callDefaultTypeInternal _xclPerfMonReadTrace_call_default_instance_;
class xclPerfMonReadTrace_response;
class xclPerfMonReadTrace_responseDefaultTypeInternal;
extern xclPerfMonReadTrace_responseDefaultTypeInternal _xclPerfMonReadTrace_response_default_instance_;
class xclPerfMonReadTrace_response_events;
class xclPerfMonReadTrace_response_eventsDefaultTypeInternal;
extern xclPerfMonReadTrace_response_eventsDefaultTypeInternal _xclPerfMonReadTrace_response_events_default_instance_;
class xclPollCompletion_call;
class xclPollCompletion_callDefaultTypeInternal;
extern xclPollCompletion_callDefaultTypeInternal _xclPollCompletion_call_default_instance_;
class xclPollCompletion_response;
class xclPollCompletion_responseDefaultTypeInternal;
extern xclPollCompletion_responseDefaultTypeInternal _xclPollCompletion_response_default_instance_;
class xclPollCompletion_response_request;
class xclPollCompletion_response_requestDefaultTypeInternal;
extern xclPollCompletion_response_requestDefaultTypeInternal _xclPollCompletion_response_request_default_instance_;
class xclReadAddrKernelCtrl_call;
class xclReadAddrKernelCtrl_callDefaultTypeInternal;
extern xclReadAddrKernelCtrl_callDefaultTypeInternal _xclReadAddrKernelCtrl_call_default_instance_;
class xclReadAddrKernelCtrl_response;
class xclReadAddrKernelCtrl_responseDefaultTypeInternal;
extern xclReadAddrKernelCtrl_responseDefaultTypeInternal _xclReadAddrKernelCtrl_response_default_instance_;
class xclReadAddrSpaceDeviceRam_call;
class xclReadAddrSpaceDeviceRam_callDefaultTypeInternal;
extern xclReadAddrSpaceDeviceRam_callDefaultTypeInternal _xclReadAddrSpaceDeviceRam_call_default_instance_;
class xclReadAddrSpaceDeviceRam_response;
class xclReadAddrSpaceDeviceRam_responseDefaultTypeInternal;
extern xclReadAddrSpaceDeviceRam_responseDefaultTypeInternal _xclReadAddrSpaceDeviceRam_response_default_instance_;
class xclReadBusStatus_call;
class xclReadBusStatus_callDefaultTypeInternal;
extern xclReadBusStatus_callDefaultTypeInternal _xclReadBusStatus_call_default_instance_;
class xclReadBusStatus_response;
class xclReadBusStatus_responseDefaultTypeInternal;
extern xclReadBusStatus_responseDefaultTypeInternal _xclReadBusStatus_response_default_instance_;
class xclReadQueue_call;
class xclReadQueue_callDefaultTypeInternal;
extern xclReadQueue_callDefaultTypeInternal _xclReadQueue_call_default_instance_;
class xclReadQueue_response;
class xclReadQueue_responseDefaultTypeInternal;
extern xclReadQueue_responseDefaultTypeInternal _xclReadQueue_response_default_instance_;
class xclSetEnvironment_call;
class xclSetEnvironment_callDefaultTypeInternal;
extern xclSetEnvironment_callDefaultTypeInternal _xclSetEnvironment_call_default_instance_;
class xclSetEnvironment_call_namevaluepair;
class xclSetEnvironment_call_namevaluepairDefaultTypeInternal;
extern xclSetEnvironment_call_namevaluepairDefaultTypeInternal _xclSetEnvironment_call_namevaluepair_default_instance_;
class xclSetEnvironment_response;
class xclSetEnvironment_responseDefaultTypeInternal;
extern xclSetEnvironment_responseDefaultTypeInternal _xclSetEnvironment_response_default_instance_;
class xclSetupInstance_call;
class xclSetupInstance_callDefaultTypeInternal;
extern xclSetupInstance_callDefaultTypeInternal _xclSetupInstance_call_default_instance_;
class xclSetupInstance_call_argflowpair;
class xclSetupInstance_call_argflowpairDefaultTypeInternal;
extern xclSetupInstance_call_argflowpairDefaultTypeInternal _xclSetupInstance_call_argflowpair_default_instance_;
class xclSetupInstance_response;
class xclSetupInstance_responseDefaultTypeInternal;
extern xclSetupInstance_responseDefaultTypeInternal _xclSetupInstance_response_default_instance_;
class xclWriteAddrKernelCtrl_call;
class xclWriteAddrKernelCtrl_callDefaultTypeInternal;
extern xclWriteAddrKernelCtrl_callDefaultTypeInternal _xclWriteAddrKernelCtrl_call_default_instance_;
class xclWriteAddrKernelCtrl_call_kernelInfo;
class xclWriteAddrKernelCtrl_call_kernelInfoDefaultTypeInternal;
extern xclWriteAddrKernelCtrl_call_kernelInfoDefaultTypeInternal _xclWriteAddrKernelCtrl_call_kernelInfo_default_instance_;
class xclWriteAddrKernelCtrl_response;
class xclWriteAddrKernelCtrl_responseDefaultTypeInternal;
extern xclWriteAddrKernelCtrl_responseDefaultTypeInternal _xclWriteAddrKernelCtrl_response_default_instance_;
class xclWriteAddrSpaceDeviceRam_call;
class xclWriteAddrSpaceDeviceRam_callDefaultTypeInternal;
extern xclWriteAddrSpaceDeviceRam_callDefaultTypeInternal _xclWriteAddrSpaceDeviceRam_call_default_instance_;
class xclWriteAddrSpaceDeviceRam_response;
class xclWriteAddrSpaceDeviceRam_responseDefaultTypeInternal;
extern xclWriteAddrSpaceDeviceRam_responseDefaultTypeInternal _xclWriteAddrSpaceDeviceRam_response_default_instance_;
class xclWriteQueue_call;
class xclWriteQueue_callDefaultTypeInternal;
extern xclWriteQueue_callDefaultTypeInternal _xclWriteQueue_call_default_instance_;
class xclWriteQueue_response;
class xclWriteQueue_responseDefaultTypeInternal;
extern xclWriteQueue_responseDefaultTypeInternal _xclWriteQueue_response_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::call_packet_info* Arena::CreateMaybeMessage<::call_packet_info>(Arena*);
template<> ::ddr_mem_msg* Arena::CreateMaybeMessage<::ddr_mem_msg>(Arena*);
template<> ::response_packet_info* Arena::CreateMaybeMessage<::response_packet_info>(Arena*);
template<> ::xclAllocDeviceBuffer_call* Arena::CreateMaybeMessage<::xclAllocDeviceBuffer_call>(Arena*);
template<> ::xclAllocDeviceBuffer_response* Arena::CreateMaybeMessage<::xclAllocDeviceBuffer_response>(Arena*);
template<> ::xclClose_call* Arena::CreateMaybeMessage<::xclClose_call>(Arena*);
template<> ::xclClose_response* Arena::CreateMaybeMessage<::xclClose_response>(Arena*);
template<> ::xclCopyBO_call* Arena::CreateMaybeMessage<::xclCopyBO_call>(Arena*);
template<> ::xclCopyBO_response* Arena::CreateMaybeMessage<::xclCopyBO_response>(Arena*);
template<> ::xclCopyBufferDevice2Host_call* Arena::CreateMaybeMessage<::xclCopyBufferDevice2Host_call>(Arena*);
template<> ::xclCopyBufferDevice2Host_response* Arena::CreateMaybeMessage<::xclCopyBufferDevice2Host_response>(Arena*);
template<> ::xclCopyBufferHost2Device_call* Arena::CreateMaybeMessage<::xclCopyBufferHost2Device_call>(Arena*);
template<> ::xclCopyBufferHost2Device_response* Arena::CreateMaybeMessage<::xclCopyBufferHost2Device_response>(Arena*);
template<> ::xclCreateQueue_call* Arena::CreateMaybeMessage<::xclCreateQueue_call>(Arena*);
template<> ::xclCreateQueue_response* Arena::CreateMaybeMessage<::xclCreateQueue_response>(Arena*);
template<> ::xclDestroyQueue_call* Arena::CreateMaybeMessage<::xclDestroyQueue_call>(Arena*);
template<> ::xclDestroyQueue_response* Arena::CreateMaybeMessage<::xclDestroyQueue_response>(Arena*);
template<> ::xclFreeDeviceBuffer_call* Arena::CreateMaybeMessage<::xclFreeDeviceBuffer_call>(Arena*);
template<> ::xclFreeDeviceBuffer_response* Arena::CreateMaybeMessage<::xclFreeDeviceBuffer_response>(Arena*);
template<> ::xclGetDebugMessages_call* Arena::CreateMaybeMessage<::xclGetDebugMessages_call>(Arena*);
template<> ::xclGetDebugMessages_response* Arena::CreateMaybeMessage<::xclGetDebugMessages_response>(Arena*);
template<> ::xclGetDeviceTimestamp_call* Arena::CreateMaybeMessage<::xclGetDeviceTimestamp_call>(Arena*);
template<> ::xclGetDeviceTimestamp_response* Arena::CreateMaybeMessage<::xclGetDeviceTimestamp_response>(Arena*);
template<> ::xclImportBO_call* Arena::CreateMaybeMessage<::xclImportBO_call>(Arena*);
template<> ::xclImportBO_response* Arena::CreateMaybeMessage<::xclImportBO_response>(Arena*);
template<> ::xclLoadBitstream_call* Arena::CreateMaybeMessage<::xclLoadBitstream_call>(Arena*);
template<> ::xclLoadBitstream_call_ddrbank* Arena::CreateMaybeMessage<::xclLoadBitstream_call_ddrbank>(Arena*);
template<> ::xclLoadBitstream_response* Arena::CreateMaybeMessage<::xclLoadBitstream_response>(Arena*);
template<> ::xclPerfMonGetTraceCount_call* Arena::CreateMaybeMessage<::xclPerfMonGetTraceCount_call>(Arena*);
template<> ::xclPerfMonGetTraceCount_response* Arena::CreateMaybeMessage<::xclPerfMonGetTraceCount_response>(Arena*);
template<> ::xclPerfMonReadCounters_Streaming_call* Arena::CreateMaybeMessage<::xclPerfMonReadCounters_Streaming_call>(Arena*);
template<> ::xclPerfMonReadCounters_Streaming_response* Arena::CreateMaybeMessage<::xclPerfMonReadCounters_Streaming_response>(Arena*);
template<> ::xclPerfMonReadCounters_call* Arena::CreateMaybeMessage<::xclPerfMonReadCounters_call>(Arena*);
template<> ::xclPerfMonReadCounters_response* Arena::CreateMaybeMessage<::xclPerfMonReadCounters_response>(Arena*);
template<> ::xclPerfMonReadTrace_Streaming_call* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_Streaming_call>(Arena*);
template<> ::xclPerfMonReadTrace_Streaming_response* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_Streaming_response>(Arena*);
template<> ::xclPerfMonReadTrace_Streaming_response_events* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_Streaming_response_events>(Arena*);
template<> ::xclPerfMonReadTrace_call* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_call>(Arena*);
template<> ::xclPerfMonReadTrace_response* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_response>(Arena*);
template<> ::xclPerfMonReadTrace_response_events* Arena::CreateMaybeMessage<::xclPerfMonReadTrace_response_events>(Arena*);
template<> ::xclPollCompletion_call* Arena::CreateMaybeMessage<::xclPollCompletion_call>(Arena*);
template<> ::xclPollCompletion_response* Arena::CreateMaybeMessage<::xclPollCompletion_response>(Arena*);
template<> ::xclPollCompletion_response_request* Arena::CreateMaybeMessage<::xclPollCompletion_response_request>(Arena*);
template<> ::xclReadAddrKernelCtrl_call* Arena::CreateMaybeMessage<::xclReadAddrKernelCtrl_call>(Arena*);
template<> ::xclReadAddrKernelCtrl_response* Arena::CreateMaybeMessage<::xclReadAddrKernelCtrl_response>(Arena*);
template<> ::xclReadAddrSpaceDeviceRam_call* Arena::CreateMaybeMessage<::xclReadAddrSpaceDeviceRam_call>(Arena*);
template<> ::xclReadAddrSpaceDeviceRam_response* Arena::CreateMaybeMessage<::xclReadAddrSpaceDeviceRam_response>(Arena*);
template<> ::xclReadBusStatus_call* Arena::CreateMaybeMessage<::xclReadBusStatus_call>(Arena*);
template<> ::xclReadBusStatus_response* Arena::CreateMaybeMessage<::xclReadBusStatus_response>(Arena*);
template<> ::xclReadQueue_call* Arena::CreateMaybeMessage<::xclReadQueue_call>(Arena*);
template<> ::xclReadQueue_response* Arena::CreateMaybeMessage<::xclReadQueue_response>(Arena*);
template<> ::xclSetEnvironment_call* Arena::CreateMaybeMessage<::xclSetEnvironment_call>(Arena*);
template<> ::xclSetEnvironment_call_namevaluepair* Arena::CreateMaybeMessage<::xclSetEnvironment_call_namevaluepair>(Arena*);
template<> ::xclSetEnvironment_response* Arena::CreateMaybeMessage<::xclSetEnvironment_response>(Arena*);
template<> ::xclSetupInstance_call* Arena::CreateMaybeMessage<::xclSetupInstance_call>(Arena*);
template<> ::xclSetupInstance_call_argflowpair* Arena::CreateMaybeMessage<::xclSetupInstance_call_argflowpair>(Arena*);
template<> ::xclSetupInstance_response* Arena::CreateMaybeMessage<::xclSetupInstance_response>(Arena*);
template<> ::xclWriteAddrKernelCtrl_call* Arena::CreateMaybeMessage<::xclWriteAddrKernelCtrl_call>(Arena*);
template<> ::xclWriteAddrKernelCtrl_call_kernelInfo* Arena::CreateMaybeMessage<::xclWriteAddrKernelCtrl_call_kernelInfo>(Arena*);
template<> ::xclWriteAddrKernelCtrl_response* Arena::CreateMaybeMessage<::xclWriteAddrKernelCtrl_response>(Arena*);
template<> ::xclWriteAddrSpaceDeviceRam_call* Arena::CreateMaybeMessage<::xclWriteAddrSpaceDeviceRam_call>(Arena*);
template<> ::xclWriteAddrSpaceDeviceRam_response* Arena::CreateMaybeMessage<::xclWriteAddrSpaceDeviceRam_response>(Arena*);
template<> ::xclWriteQueue_call* Arena::CreateMaybeMessage<::xclWriteQueue_call>(Arena*);
template<> ::xclWriteQueue_response* Arena::CreateMaybeMessage<::xclWriteQueue_response>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

class call_packet_info :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:call_packet_info) */ {
 public:
  call_packet_info();
  virtual ~call_packet_info();

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

  inline call_packet_info& operator=(const call_packet_info& from) {
    CopyFrom(from);
    return *this;
  }
  inline call_packet_info& operator=(call_packet_info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const call_packet_info& default_instance();

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

  friend void swap(call_packet_info& a, call_packet_info& b) {
    a.Swap(&b);
  }
  inline void Swap(call_packet_info* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline call_packet_info* New() const final {
    return CreateMaybeMessage<call_packet_info>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(call_packet_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "call_packet_info";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSizeFieldNumber = 1,
    kXclApiFieldNumber = 2,
  };
  // required fixed64 size = 1;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional fixed32 xcl_api = 2;
  bool has_xcl_api() const;
  void clear_xcl_api();
  ::PROTOBUF_NAMESPACE_ID::uint32 xcl_api() const;
  void set_xcl_api(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:call_packet_info)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 xcl_api_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class response_packet_info :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:response_packet_info) */ {
 public:
  response_packet_info();
  virtual ~response_packet_info();

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

  inline response_packet_info& operator=(const response_packet_info& from) {
    CopyFrom(from);
    return *this;
  }
  inline response_packet_info& operator=(response_packet_info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const response_packet_info& default_instance();

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

  friend void swap(response_packet_info& a, response_packet_info& b) {
    a.Swap(&b);
  }
  inline void Swap(response_packet_info* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline response_packet_info* New() const final {
    return CreateMaybeMessage<response_packet_info>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(response_packet_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "response_packet_info";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSizeFieldNumber = 1,
    kXclApiFieldNumber = 2,
  };
  // required fixed64 size = 1;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional fixed32 xcl_api = 2;
  bool has_xcl_api() const;
  void clear_xcl_api();
  ::PROTOBUF_NAMESPACE_ID::uint32 xcl_api() const;
  void set_xcl_api(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:response_packet_info)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 xcl_api_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetEnvironment_call_namevaluepair :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetEnvironment_call.namevaluepair) */ {
 public:
  xclSetEnvironment_call_namevaluepair();
  virtual ~xclSetEnvironment_call_namevaluepair();

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

  inline xclSetEnvironment_call_namevaluepair& operator=(const xclSetEnvironment_call_namevaluepair& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetEnvironment_call_namevaluepair& operator=(xclSetEnvironment_call_namevaluepair&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetEnvironment_call_namevaluepair& default_instance();

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

  friend void swap(xclSetEnvironment_call_namevaluepair& a, xclSetEnvironment_call_namevaluepair& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetEnvironment_call_namevaluepair* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetEnvironment_call_namevaluepair* New() const final {
    return CreateMaybeMessage<xclSetEnvironment_call_namevaluepair>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetEnvironment_call_namevaluepair* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetEnvironment_call.namevaluepair";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional string value = 2;
  bool has_value() const;
  void clear_value();
  const std::string& value() const;
  void set_value(const std::string& value);
  void set_value(std::string&& value);
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  std::string* mutable_value();
  std::string* release_value();
  void set_allocated_value(std::string* value);

  // @@protoc_insertion_point(class_scope:xclSetEnvironment_call.namevaluepair)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetEnvironment_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetEnvironment_call) */ {
 public:
  xclSetEnvironment_call();
  virtual ~xclSetEnvironment_call();

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

  inline xclSetEnvironment_call& operator=(const xclSetEnvironment_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetEnvironment_call& operator=(xclSetEnvironment_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetEnvironment_call& default_instance();

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

  friend void swap(xclSetEnvironment_call& a, xclSetEnvironment_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetEnvironment_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetEnvironment_call* New() const final {
    return CreateMaybeMessage<xclSetEnvironment_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetEnvironment_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetEnvironment_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclSetEnvironment_call_namevaluepair namevaluepair;

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

  enum : int {
    kEnvironmentFieldNumber = 3,
  };
  // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
  int environment_size() const;
  void clear_environment();
  ::xclSetEnvironment_call_namevaluepair* mutable_environment(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetEnvironment_call_namevaluepair >*
      mutable_environment();
  const ::xclSetEnvironment_call_namevaluepair& environment(int index) const;
  ::xclSetEnvironment_call_namevaluepair* add_environment();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetEnvironment_call_namevaluepair >&
      environment() const;

  // @@protoc_insertion_point(class_scope:xclSetEnvironment_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetEnvironment_call_namevaluepair > environment_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetEnvironment_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetEnvironment_response) */ {
 public:
  xclSetEnvironment_response();
  virtual ~xclSetEnvironment_response();

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

  inline xclSetEnvironment_response& operator=(const xclSetEnvironment_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetEnvironment_response& operator=(xclSetEnvironment_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetEnvironment_response& default_instance();

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

  friend void swap(xclSetEnvironment_response& a, xclSetEnvironment_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetEnvironment_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetEnvironment_response* New() const final {
    return CreateMaybeMessage<xclSetEnvironment_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetEnvironment_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetEnvironment_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclSetEnvironment_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclLoadBitstream_call_ddrbank :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclLoadBitstream_call.ddrbank) */ {
 public:
  xclLoadBitstream_call_ddrbank();
  virtual ~xclLoadBitstream_call_ddrbank();

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

  inline xclLoadBitstream_call_ddrbank& operator=(const xclLoadBitstream_call_ddrbank& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclLoadBitstream_call_ddrbank& operator=(xclLoadBitstream_call_ddrbank&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclLoadBitstream_call_ddrbank& default_instance();

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

  friend void swap(xclLoadBitstream_call_ddrbank& a, xclLoadBitstream_call_ddrbank& b) {
    a.Swap(&b);
  }
  inline void Swap(xclLoadBitstream_call_ddrbank* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclLoadBitstream_call_ddrbank* New() const final {
    return CreateMaybeMessage<xclLoadBitstream_call_ddrbank>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclLoadBitstream_call_ddrbank* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclLoadBitstream_call.ddrbank";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSizeFieldNumber = 7,
  };
  // optional uint64 size = 7;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclLoadBitstream_call.ddrbank)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclLoadBitstream_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclLoadBitstream_call) */ {
 public:
  xclLoadBitstream_call();
  virtual ~xclLoadBitstream_call();

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

  inline xclLoadBitstream_call& operator=(const xclLoadBitstream_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclLoadBitstream_call& operator=(xclLoadBitstream_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclLoadBitstream_call& default_instance();

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

  friend void swap(xclLoadBitstream_call& a, xclLoadBitstream_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclLoadBitstream_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclLoadBitstream_call* New() const final {
    return CreateMaybeMessage<xclLoadBitstream_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclLoadBitstream_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclLoadBitstream_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclLoadBitstream_call_ddrbank ddrbank;

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

  enum : int {
    kDdrbanksFieldNumber = 8,
    kXmlfileFieldNumber = 1,
    kDlopenfilenameFieldNumber = 2,
    kDevicenameFieldNumber = 3,
    kDevicedirectoryFieldNumber = 4,
    kBinarydirectoryFieldNumber = 5,
    kVerboseFieldNumber = 6,
  };
  // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
  int ddrbanks_size() const;
  void clear_ddrbanks();
  ::xclLoadBitstream_call_ddrbank* mutable_ddrbanks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclLoadBitstream_call_ddrbank >*
      mutable_ddrbanks();
  const ::xclLoadBitstream_call_ddrbank& ddrbanks(int index) const;
  ::xclLoadBitstream_call_ddrbank* add_ddrbanks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclLoadBitstream_call_ddrbank >&
      ddrbanks() const;

  // required bytes xmlfile = 1;
  bool has_xmlfile() const;
  void clear_xmlfile();
  const std::string& xmlfile() const;
  void set_xmlfile(const std::string& value);
  void set_xmlfile(std::string&& value);
  void set_xmlfile(const char* value);
  void set_xmlfile(const void* value, size_t size);
  std::string* mutable_xmlfile();
  std::string* release_xmlfile();
  void set_allocated_xmlfile(std::string* xmlfile);

  // required bytes dlopenfilename = 2;
  bool has_dlopenfilename() const;
  void clear_dlopenfilename();
  const std::string& dlopenfilename() const;
  void set_dlopenfilename(const std::string& value);
  void set_dlopenfilename(std::string&& value);
  void set_dlopenfilename(const char* value);
  void set_dlopenfilename(const void* value, size_t size);
  std::string* mutable_dlopenfilename();
  std::string* release_dlopenfilename();
  void set_allocated_dlopenfilename(std::string* dlopenfilename);

  // required bytes devicename = 3;
  bool has_devicename() const;
  void clear_devicename();
  const std::string& devicename() const;
  void set_devicename(const std::string& value);
  void set_devicename(std::string&& value);
  void set_devicename(const char* value);
  void set_devicename(const void* value, size_t size);
  std::string* mutable_devicename();
  std::string* release_devicename();
  void set_allocated_devicename(std::string* devicename);

  // required bytes devicedirectory = 4;
  bool has_devicedirectory() const;
  void clear_devicedirectory();
  const std::string& devicedirectory() const;
  void set_devicedirectory(const std::string& value);
  void set_devicedirectory(std::string&& value);
  void set_devicedirectory(const char* value);
  void set_devicedirectory(const void* value, size_t size);
  std::string* mutable_devicedirectory();
  std::string* release_devicedirectory();
  void set_allocated_devicedirectory(std::string* devicedirectory);

  // required bytes binarydirectory = 5;
  bool has_binarydirectory() const;
  void clear_binarydirectory();
  const std::string& binarydirectory() const;
  void set_binarydirectory(const std::string& value);
  void set_binarydirectory(std::string&& value);
  void set_binarydirectory(const char* value);
  void set_binarydirectory(const void* value, size_t size);
  std::string* mutable_binarydirectory();
  std::string* release_binarydirectory();
  void set_allocated_binarydirectory(std::string* binarydirectory);

  // required bool verbose = 6;
  bool has_verbose() const;
  void clear_verbose();
  bool verbose() const;
  void set_verbose(bool value);

  // @@protoc_insertion_point(class_scope:xclLoadBitstream_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclLoadBitstream_call_ddrbank > ddrbanks_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xmlfile_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dlopenfilename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicedirectory_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binarydirectory_;
  bool verbose_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclLoadBitstream_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclLoadBitstream_response) */ {
 public:
  xclLoadBitstream_response();
  virtual ~xclLoadBitstream_response();

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

  inline xclLoadBitstream_response& operator=(const xclLoadBitstream_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclLoadBitstream_response& operator=(xclLoadBitstream_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclLoadBitstream_response& default_instance();

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

  friend void swap(xclLoadBitstream_response& a, xclLoadBitstream_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclLoadBitstream_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclLoadBitstream_response* New() const final {
    return CreateMaybeMessage<xclLoadBitstream_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclLoadBitstream_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclLoadBitstream_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // required bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclLoadBitstream_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclAllocDeviceBuffer_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclAllocDeviceBuffer_call) */ {
 public:
  xclAllocDeviceBuffer_call();
  virtual ~xclAllocDeviceBuffer_call();

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

  inline xclAllocDeviceBuffer_call& operator=(const xclAllocDeviceBuffer_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclAllocDeviceBuffer_call& operator=(xclAllocDeviceBuffer_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclAllocDeviceBuffer_call& default_instance();

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

  friend void swap(xclAllocDeviceBuffer_call& a, xclAllocDeviceBuffer_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclAllocDeviceBuffer_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclAllocDeviceBuffer_call* New() const final {
    return CreateMaybeMessage<xclAllocDeviceBuffer_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclAllocDeviceBuffer_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclAllocDeviceBuffer_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDdraddressFieldNumber = 1,
    kSizeFieldNumber = 2,
    kPeertopeerFieldNumber = 3,
  };
  // required uint64 ddraddress = 1;
  bool has_ddraddress() const;
  void clear_ddraddress();
  ::PROTOBUF_NAMESPACE_ID::uint64 ddraddress() const;
  void set_ddraddress(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint64 size = 2;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional bool peertopeer = 3;
  bool has_peertopeer() const;
  void clear_peertopeer();
  bool peertopeer() const;
  void set_peertopeer(bool value);

  // @@protoc_insertion_point(class_scope:xclAllocDeviceBuffer_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 ddraddress_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  bool peertopeer_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclAllocDeviceBuffer_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclAllocDeviceBuffer_response) */ {
 public:
  xclAllocDeviceBuffer_response();
  virtual ~xclAllocDeviceBuffer_response();

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

  inline xclAllocDeviceBuffer_response& operator=(const xclAllocDeviceBuffer_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclAllocDeviceBuffer_response& operator=(xclAllocDeviceBuffer_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclAllocDeviceBuffer_response& default_instance();

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

  friend void swap(xclAllocDeviceBuffer_response& a, xclAllocDeviceBuffer_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclAllocDeviceBuffer_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclAllocDeviceBuffer_response* New() const final {
    return CreateMaybeMessage<xclAllocDeviceBuffer_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclAllocDeviceBuffer_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclAllocDeviceBuffer_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFilenameFieldNumber = 2,
    kAckFieldNumber = 1,
  };
  // optional string filename = 2;
  bool has_filename() const;
  void clear_filename();
  const std::string& filename() const;
  void set_filename(const std::string& value);
  void set_filename(std::string&& value);
  void set_filename(const char* value);
  void set_filename(const char* value, size_t size);
  std::string* mutable_filename();
  std::string* release_filename();
  void set_allocated_filename(std::string* filename);

  // required bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclAllocDeviceBuffer_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclFreeDeviceBuffer_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclFreeDeviceBuffer_call) */ {
 public:
  xclFreeDeviceBuffer_call();
  virtual ~xclFreeDeviceBuffer_call();

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

  inline xclFreeDeviceBuffer_call& operator=(const xclFreeDeviceBuffer_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclFreeDeviceBuffer_call& operator=(xclFreeDeviceBuffer_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclFreeDeviceBuffer_call& default_instance();

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

  friend void swap(xclFreeDeviceBuffer_call& a, xclFreeDeviceBuffer_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclFreeDeviceBuffer_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclFreeDeviceBuffer_call* New() const final {
    return CreateMaybeMessage<xclFreeDeviceBuffer_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclFreeDeviceBuffer_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclFreeDeviceBuffer_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDdraddressFieldNumber = 1,
  };
  // required uint64 ddraddress = 1;
  bool has_ddraddress() const;
  void clear_ddraddress();
  ::PROTOBUF_NAMESPACE_ID::uint64 ddraddress() const;
  void set_ddraddress(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclFreeDeviceBuffer_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 ddraddress_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclFreeDeviceBuffer_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclFreeDeviceBuffer_response) */ {
 public:
  xclFreeDeviceBuffer_response();
  virtual ~xclFreeDeviceBuffer_response();

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

  inline xclFreeDeviceBuffer_response& operator=(const xclFreeDeviceBuffer_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclFreeDeviceBuffer_response& operator=(xclFreeDeviceBuffer_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclFreeDeviceBuffer_response& default_instance();

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

  friend void swap(xclFreeDeviceBuffer_response& a, xclFreeDeviceBuffer_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclFreeDeviceBuffer_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclFreeDeviceBuffer_response* New() const final {
    return CreateMaybeMessage<xclFreeDeviceBuffer_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclFreeDeviceBuffer_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclFreeDeviceBuffer_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // required bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclFreeDeviceBuffer_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclClose_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclClose_call) */ {
 public:
  xclClose_call();
  virtual ~xclClose_call();

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

  inline xclClose_call& operator=(const xclClose_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclClose_call& operator=(xclClose_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclClose_call& default_instance();

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

  friend void swap(xclClose_call& a, xclClose_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclClose_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclClose_call* New() const final {
    return CreateMaybeMessage<xclClose_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclClose_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclClose_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXclDeviceHandleFieldNumber = 2,
    kCloseallFieldNumber = 3,
  };
  // optional bytes xclDeviceHandle = 2;
  bool has_xcldevicehandle() const;
  void clear_xcldevicehandle();
  const std::string& xcldevicehandle() const;
  void set_xcldevicehandle(const std::string& value);
  void set_xcldevicehandle(std::string&& value);
  void set_xcldevicehandle(const char* value);
  void set_xcldevicehandle(const void* value, size_t size);
  std::string* mutable_xcldevicehandle();
  std::string* release_xcldevicehandle();
  void set_allocated_xcldevicehandle(std::string* xcldevicehandle);

  // optional bool closeall = 3;
  bool has_closeall() const;
  void clear_closeall();
  bool closeall() const;
  void set_closeall(bool value);

  // @@protoc_insertion_point(class_scope:xclClose_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xcldevicehandle_;
  bool closeall_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclClose_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclClose_response) */ {
 public:
  xclClose_response();
  virtual ~xclClose_response();

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

  inline xclClose_response& operator=(const xclClose_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclClose_response& operator=(xclClose_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclClose_response& default_instance();

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

  friend void swap(xclClose_response& a, xclClose_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclClose_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclClose_response* New() const final {
    return CreateMaybeMessage<xclClose_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclClose_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclClose_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValidFieldNumber = 1,
  };
  // required bool valid = 1;
  bool has_valid() const;
  void clear_valid();
  bool valid() const;
  void set_valid(bool value);

  // @@protoc_insertion_point(class_scope:xclClose_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool valid_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBufferHost2Device_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBufferHost2Device_call) */ {
 public:
  xclCopyBufferHost2Device_call();
  virtual ~xclCopyBufferHost2Device_call();

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

  inline xclCopyBufferHost2Device_call& operator=(const xclCopyBufferHost2Device_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBufferHost2Device_call& operator=(xclCopyBufferHost2Device_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBufferHost2Device_call& default_instance();

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

  friend void swap(xclCopyBufferHost2Device_call& a, xclCopyBufferHost2Device_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBufferHost2Device_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBufferHost2Device_call* New() const final {
    return CreateMaybeMessage<xclCopyBufferHost2Device_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBufferHost2Device_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBufferHost2Device_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXclDeviceHandleFieldNumber = 2,
    kSrcFieldNumber = 4,
    kDestFieldNumber = 3,
    kSizeFieldNumber = 5,
    kSeekFieldNumber = 6,
    kSpaceFieldNumber = 7,
  };
  // required bytes xclDeviceHandle = 2;
  bool has_xcldevicehandle() const;
  void clear_xcldevicehandle();
  const std::string& xcldevicehandle() const;
  void set_xcldevicehandle(const std::string& value);
  void set_xcldevicehandle(std::string&& value);
  void set_xcldevicehandle(const char* value);
  void set_xcldevicehandle(const void* value, size_t size);
  std::string* mutable_xcldevicehandle();
  std::string* release_xcldevicehandle();
  void set_allocated_xcldevicehandle(std::string* xcldevicehandle);

  // required bytes src = 4;
  bool has_src() const;
  void clear_src();
  const std::string& src() const;
  void set_src(const std::string& value);
  void set_src(std::string&& value);
  void set_src(const char* value);
  void set_src(const void* value, size_t size);
  std::string* mutable_src();
  std::string* release_src();
  void set_allocated_src(std::string* src);

  // required uint64 dest = 3;
  bool has_dest() const;
  void clear_dest();
  ::PROTOBUF_NAMESPACE_ID::uint64 dest() const;
  void set_dest(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint64 size = 5;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint64 seek = 6;
  bool has_seek() const;
  void clear_seek();
  ::PROTOBUF_NAMESPACE_ID::uint64 seek() const;
  void set_seek(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 space = 7;
  bool has_space() const;
  void clear_space();
  ::PROTOBUF_NAMESPACE_ID::uint32 space() const;
  void set_space(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclCopyBufferHost2Device_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xcldevicehandle_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr src_;
  ::PROTOBUF_NAMESPACE_ID::uint64 dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 seek_;
  ::PROTOBUF_NAMESPACE_ID::uint32 space_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBufferHost2Device_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBufferHost2Device_response) */ {
 public:
  xclCopyBufferHost2Device_response();
  virtual ~xclCopyBufferHost2Device_response();

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

  inline xclCopyBufferHost2Device_response& operator=(const xclCopyBufferHost2Device_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBufferHost2Device_response& operator=(xclCopyBufferHost2Device_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBufferHost2Device_response& default_instance();

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

  friend void swap(xclCopyBufferHost2Device_response& a, xclCopyBufferHost2Device_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBufferHost2Device_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBufferHost2Device_response* New() const final {
    return CreateMaybeMessage<xclCopyBufferHost2Device_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBufferHost2Device_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBufferHost2Device_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSizeFieldNumber = 1,
  };
  // required uint64 size = 1;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclCopyBufferHost2Device_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBufferDevice2Host_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBufferDevice2Host_call) */ {
 public:
  xclCopyBufferDevice2Host_call();
  virtual ~xclCopyBufferDevice2Host_call();

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

  inline xclCopyBufferDevice2Host_call& operator=(const xclCopyBufferDevice2Host_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBufferDevice2Host_call& operator=(xclCopyBufferDevice2Host_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBufferDevice2Host_call& default_instance();

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

  friend void swap(xclCopyBufferDevice2Host_call& a, xclCopyBufferDevice2Host_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBufferDevice2Host_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBufferDevice2Host_call* New() const final {
    return CreateMaybeMessage<xclCopyBufferDevice2Host_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBufferDevice2Host_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBufferDevice2Host_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXclDeviceHandleFieldNumber = 2,
    kDestFieldNumber = 3,
    kSrcFieldNumber = 4,
    kSizeFieldNumber = 5,
    kSkipFieldNumber = 6,
    kSpaceFieldNumber = 7,
  };
  // required bytes xclDeviceHandle = 2;
  bool has_xcldevicehandle() const;
  void clear_xcldevicehandle();
  const std::string& xcldevicehandle() const;
  void set_xcldevicehandle(const std::string& value);
  void set_xcldevicehandle(std::string&& value);
  void set_xcldevicehandle(const char* value);
  void set_xcldevicehandle(const void* value, size_t size);
  std::string* mutable_xcldevicehandle();
  std::string* release_xcldevicehandle();
  void set_allocated_xcldevicehandle(std::string* xcldevicehandle);

  // required bytes dest = 3;
  bool has_dest() const;
  void clear_dest();
  const std::string& dest() const;
  void set_dest(const std::string& value);
  void set_dest(std::string&& value);
  void set_dest(const char* value);
  void set_dest(const void* value, size_t size);
  std::string* mutable_dest();
  std::string* release_dest();
  void set_allocated_dest(std::string* dest);

  // required uint64 src = 4;
  bool has_src() const;
  void clear_src();
  ::PROTOBUF_NAMESPACE_ID::uint64 src() const;
  void set_src(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint64 size = 5;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint64 skip = 6;
  bool has_skip() const;
  void clear_skip();
  ::PROTOBUF_NAMESPACE_ID::uint64 skip() const;
  void set_skip(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 space = 7;
  bool has_space() const;
  void clear_space();
  ::PROTOBUF_NAMESPACE_ID::uint32 space() const;
  void set_space(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclCopyBufferDevice2Host_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xcldevicehandle_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 src_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 skip_;
  ::PROTOBUF_NAMESPACE_ID::uint32 space_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBufferDevice2Host_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBufferDevice2Host_response) */ {
 public:
  xclCopyBufferDevice2Host_response();
  virtual ~xclCopyBufferDevice2Host_response();

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

  inline xclCopyBufferDevice2Host_response& operator=(const xclCopyBufferDevice2Host_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBufferDevice2Host_response& operator=(xclCopyBufferDevice2Host_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBufferDevice2Host_response& default_instance();

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

  friend void swap(xclCopyBufferDevice2Host_response& a, xclCopyBufferDevice2Host_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBufferDevice2Host_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBufferDevice2Host_response* New() const final {
    return CreateMaybeMessage<xclCopyBufferDevice2Host_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBufferDevice2Host_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBufferDevice2Host_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDestFieldNumber = 2,
    kSizeFieldNumber = 1,
  };
  // required bytes dest = 2;
  bool has_dest() const;
  void clear_dest();
  const std::string& dest() const;
  void set_dest(const std::string& value);
  void set_dest(std::string&& value);
  void set_dest(const char* value);
  void set_dest(const void* value, size_t size);
  std::string* mutable_dest();
  std::string* release_dest();
  void set_allocated_dest(std::string* dest);

  // required uint64 size = 1;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclCopyBufferDevice2Host_response)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteAddrSpaceDeviceRam_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteAddrSpaceDeviceRam_call) */ {
 public:
  xclWriteAddrSpaceDeviceRam_call();
  virtual ~xclWriteAddrSpaceDeviceRam_call();

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

  inline xclWriteAddrSpaceDeviceRam_call& operator=(const xclWriteAddrSpaceDeviceRam_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteAddrSpaceDeviceRam_call& operator=(xclWriteAddrSpaceDeviceRam_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteAddrSpaceDeviceRam_call& default_instance();

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

  friend void swap(xclWriteAddrSpaceDeviceRam_call& a, xclWriteAddrSpaceDeviceRam_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteAddrSpaceDeviceRam_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteAddrSpaceDeviceRam_call* New() const final {
    return CreateMaybeMessage<xclWriteAddrSpaceDeviceRam_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteAddrSpaceDeviceRam_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteAddrSpaceDeviceRam_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 4,
    kAddrFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // required bytes data = 4;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required uint64 addr = 2;
  bool has_addr() const;
  void clear_addr();
  ::PROTOBUF_NAMESPACE_ID::uint64 addr() const;
  void set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint32 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclWriteAddrSpaceDeviceRam_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 addr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteAddrSpaceDeviceRam_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteAddrSpaceDeviceRam_response) */ {
 public:
  xclWriteAddrSpaceDeviceRam_response();
  virtual ~xclWriteAddrSpaceDeviceRam_response();

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

  inline xclWriteAddrSpaceDeviceRam_response& operator=(const xclWriteAddrSpaceDeviceRam_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteAddrSpaceDeviceRam_response& operator=(xclWriteAddrSpaceDeviceRam_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteAddrSpaceDeviceRam_response& default_instance();

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

  friend void swap(xclWriteAddrSpaceDeviceRam_response& a, xclWriteAddrSpaceDeviceRam_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteAddrSpaceDeviceRam_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteAddrSpaceDeviceRam_response* New() const final {
    return CreateMaybeMessage<xclWriteAddrSpaceDeviceRam_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteAddrSpaceDeviceRam_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteAddrSpaceDeviceRam_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValidFieldNumber = 1,
  };
  // required bool valid = 1;
  bool has_valid() const;
  void clear_valid();
  bool valid() const;
  void set_valid(bool value);

  // @@protoc_insertion_point(class_scope:xclWriteAddrSpaceDeviceRam_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool valid_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteAddrKernelCtrl_call_kernelInfo :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteAddrKernelCtrl_call.kernelInfo) */ {
 public:
  xclWriteAddrKernelCtrl_call_kernelInfo();
  virtual ~xclWriteAddrKernelCtrl_call_kernelInfo();

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

  inline xclWriteAddrKernelCtrl_call_kernelInfo& operator=(const xclWriteAddrKernelCtrl_call_kernelInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteAddrKernelCtrl_call_kernelInfo& operator=(xclWriteAddrKernelCtrl_call_kernelInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteAddrKernelCtrl_call_kernelInfo& default_instance();

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

  friend void swap(xclWriteAddrKernelCtrl_call_kernelInfo& a, xclWriteAddrKernelCtrl_call_kernelInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteAddrKernelCtrl_call_kernelInfo* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteAddrKernelCtrl_call_kernelInfo* New() const final {
    return CreateMaybeMessage<xclWriteAddrKernelCtrl_call_kernelInfo>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteAddrKernelCtrl_call_kernelInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteAddrKernelCtrl_call.kernelInfo";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 3,
    kAddrFieldNumber = 1,
    kSizeFieldNumber = 2,
  };
  // optional string name = 3;
  bool has_name() const;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional uint64 addr = 1;
  bool has_addr() const;
  void clear_addr();
  ::PROTOBUF_NAMESPACE_ID::uint64 addr() const;
  void set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 size = 2;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclWriteAddrKernelCtrl_call.kernelInfo)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::uint64 addr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteAddrKernelCtrl_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteAddrKernelCtrl_call) */ {
 public:
  xclWriteAddrKernelCtrl_call();
  virtual ~xclWriteAddrKernelCtrl_call();

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

  inline xclWriteAddrKernelCtrl_call& operator=(const xclWriteAddrKernelCtrl_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteAddrKernelCtrl_call& operator=(xclWriteAddrKernelCtrl_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteAddrKernelCtrl_call& default_instance();

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

  friend void swap(xclWriteAddrKernelCtrl_call& a, xclWriteAddrKernelCtrl_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteAddrKernelCtrl_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteAddrKernelCtrl_call* New() const final {
    return CreateMaybeMessage<xclWriteAddrKernelCtrl_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteAddrKernelCtrl_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteAddrKernelCtrl_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclWriteAddrKernelCtrl_call_kernelInfo kernelInfo;

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

  enum : int {
    kKernelInfoFieldNumber = 5,
    kDataFieldNumber = 4,
    kAddrFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
  int kernel_info_size() const;
  void clear_kernel_info();
  ::xclWriteAddrKernelCtrl_call_kernelInfo* mutable_kernel_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclWriteAddrKernelCtrl_call_kernelInfo >*
      mutable_kernel_info();
  const ::xclWriteAddrKernelCtrl_call_kernelInfo& kernel_info(int index) const;
  ::xclWriteAddrKernelCtrl_call_kernelInfo* add_kernel_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclWriteAddrKernelCtrl_call_kernelInfo >&
      kernel_info() const;

  // required bytes data = 4;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required uint64 addr = 2;
  bool has_addr() const;
  void clear_addr();
  ::PROTOBUF_NAMESPACE_ID::uint64 addr() const;
  void set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint32 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclWriteAddrKernelCtrl_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclWriteAddrKernelCtrl_call_kernelInfo > kernel_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 addr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteAddrKernelCtrl_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteAddrKernelCtrl_response) */ {
 public:
  xclWriteAddrKernelCtrl_response();
  virtual ~xclWriteAddrKernelCtrl_response();

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

  inline xclWriteAddrKernelCtrl_response& operator=(const xclWriteAddrKernelCtrl_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteAddrKernelCtrl_response& operator=(xclWriteAddrKernelCtrl_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteAddrKernelCtrl_response& default_instance();

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

  friend void swap(xclWriteAddrKernelCtrl_response& a, xclWriteAddrKernelCtrl_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteAddrKernelCtrl_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteAddrKernelCtrl_response* New() const final {
    return CreateMaybeMessage<xclWriteAddrKernelCtrl_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteAddrKernelCtrl_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteAddrKernelCtrl_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValidFieldNumber = 1,
  };
  // required bool valid = 1;
  bool has_valid() const;
  void clear_valid();
  bool valid() const;
  void set_valid(bool value);

  // @@protoc_insertion_point(class_scope:xclWriteAddrKernelCtrl_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool valid_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadAddrSpaceDeviceRam_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadAddrSpaceDeviceRam_call) */ {
 public:
  xclReadAddrSpaceDeviceRam_call();
  virtual ~xclReadAddrSpaceDeviceRam_call();

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

  inline xclReadAddrSpaceDeviceRam_call& operator=(const xclReadAddrSpaceDeviceRam_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadAddrSpaceDeviceRam_call& operator=(xclReadAddrSpaceDeviceRam_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadAddrSpaceDeviceRam_call& default_instance();

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

  friend void swap(xclReadAddrSpaceDeviceRam_call& a, xclReadAddrSpaceDeviceRam_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadAddrSpaceDeviceRam_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadAddrSpaceDeviceRam_call* New() const final {
    return CreateMaybeMessage<xclReadAddrSpaceDeviceRam_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadAddrSpaceDeviceRam_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadAddrSpaceDeviceRam_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 4,
    kAddrFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // optional bytes data = 4;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required uint64 addr = 2;
  bool has_addr() const;
  void clear_addr();
  ::PROTOBUF_NAMESPACE_ID::uint64 addr() const;
  void set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint32 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclReadAddrSpaceDeviceRam_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 addr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadAddrSpaceDeviceRam_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadAddrSpaceDeviceRam_response) */ {
 public:
  xclReadAddrSpaceDeviceRam_response();
  virtual ~xclReadAddrSpaceDeviceRam_response();

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

  inline xclReadAddrSpaceDeviceRam_response& operator=(const xclReadAddrSpaceDeviceRam_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadAddrSpaceDeviceRam_response& operator=(xclReadAddrSpaceDeviceRam_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadAddrSpaceDeviceRam_response& default_instance();

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

  friend void swap(xclReadAddrSpaceDeviceRam_response& a, xclReadAddrSpaceDeviceRam_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadAddrSpaceDeviceRam_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadAddrSpaceDeviceRam_response* New() const final {
    return CreateMaybeMessage<xclReadAddrSpaceDeviceRam_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadAddrSpaceDeviceRam_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadAddrSpaceDeviceRam_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 2,
    kValidFieldNumber = 1,
  };
  // optional bytes data = 2;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required bool valid = 1;
  bool has_valid() const;
  void clear_valid();
  bool valid() const;
  void set_valid(bool value);

  // @@protoc_insertion_point(class_scope:xclReadAddrSpaceDeviceRam_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  bool valid_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadAddrKernelCtrl_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadAddrKernelCtrl_call) */ {
 public:
  xclReadAddrKernelCtrl_call();
  virtual ~xclReadAddrKernelCtrl_call();

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

  inline xclReadAddrKernelCtrl_call& operator=(const xclReadAddrKernelCtrl_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadAddrKernelCtrl_call& operator=(xclReadAddrKernelCtrl_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadAddrKernelCtrl_call& default_instance();

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

  friend void swap(xclReadAddrKernelCtrl_call& a, xclReadAddrKernelCtrl_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadAddrKernelCtrl_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadAddrKernelCtrl_call* New() const final {
    return CreateMaybeMessage<xclReadAddrKernelCtrl_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadAddrKernelCtrl_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadAddrKernelCtrl_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 4,
    kAddrFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // optional bytes data = 4;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required uint64 addr = 2;
  bool has_addr() const;
  void clear_addr();
  ::PROTOBUF_NAMESPACE_ID::uint64 addr() const;
  void set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // required uint32 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclReadAddrKernelCtrl_call)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 addr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadAddrKernelCtrl_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadAddrKernelCtrl_response) */ {
 public:
  xclReadAddrKernelCtrl_response();
  virtual ~xclReadAddrKernelCtrl_response();

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

  inline xclReadAddrKernelCtrl_response& operator=(const xclReadAddrKernelCtrl_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadAddrKernelCtrl_response& operator=(xclReadAddrKernelCtrl_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadAddrKernelCtrl_response& default_instance();

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

  friend void swap(xclReadAddrKernelCtrl_response& a, xclReadAddrKernelCtrl_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadAddrKernelCtrl_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadAddrKernelCtrl_response* New() const final {
    return CreateMaybeMessage<xclReadAddrKernelCtrl_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadAddrKernelCtrl_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadAddrKernelCtrl_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 2,
    kValidFieldNumber = 1,
  };
  // optional bytes data = 2;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // required bool valid = 1;
  bool has_valid() const;
  void clear_valid();
  bool valid() const;
  void set_valid(bool value);

  // @@protoc_insertion_point(class_scope:xclReadAddrKernelCtrl_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  bool valid_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadCounters_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadCounters_call) */ {
 public:
  xclPerfMonReadCounters_call();
  virtual ~xclPerfMonReadCounters_call();

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

  inline xclPerfMonReadCounters_call& operator=(const xclPerfMonReadCounters_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadCounters_call& operator=(xclPerfMonReadCounters_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadCounters_call& default_instance();

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

  friend void swap(xclPerfMonReadCounters_call& a, xclPerfMonReadCounters_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadCounters_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadCounters_call* New() const final {
    return CreateMaybeMessage<xclPerfMonReadCounters_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadCounters_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadCounters_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotnameFieldNumber = 1,
    kAccelFieldNumber = 2,
  };
  // required string slotname = 1;
  bool has_slotname() const;
  void clear_slotname();
  const std::string& slotname() const;
  void set_slotname(const std::string& value);
  void set_slotname(std::string&& value);
  void set_slotname(const char* value);
  void set_slotname(const char* value, size_t size);
  std::string* mutable_slotname();
  std::string* release_slotname();
  void set_allocated_slotname(std::string* slotname);

  // optional bool accel = 2;
  bool has_accel() const;
  void clear_accel();
  bool accel() const;
  void set_accel(bool value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadCounters_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slotname_;
  bool accel_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadCounters_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadCounters_response) */ {
 public:
  xclPerfMonReadCounters_response();
  virtual ~xclPerfMonReadCounters_response();

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

  inline xclPerfMonReadCounters_response& operator=(const xclPerfMonReadCounters_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadCounters_response& operator=(xclPerfMonReadCounters_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadCounters_response& default_instance();

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

  friend void swap(xclPerfMonReadCounters_response& a, xclPerfMonReadCounters_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadCounters_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadCounters_response* New() const final {
    return CreateMaybeMessage<xclPerfMonReadCounters_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadCounters_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadCounters_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWrByteCountFieldNumber = 1,
    kWrTransCountFieldNumber = 2,
    kTotalWrLatencyFieldNumber = 3,
    kRdByteCountFieldNumber = 4,
    kRdTransCountFieldNumber = 5,
    kTotalRdLatencyFieldNumber = 6,
  };
  // optional uint32 wr_byte_count = 1;
  bool has_wr_byte_count() const;
  void clear_wr_byte_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_byte_count() const;
  void set_wr_byte_count(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 wr_trans_count = 2;
  bool has_wr_trans_count() const;
  void clear_wr_trans_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_trans_count() const;
  void set_wr_trans_count(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 total_wr_latency = 3;
  bool has_total_wr_latency() const;
  void clear_total_wr_latency();
  ::PROTOBUF_NAMESPACE_ID::uint32 total_wr_latency() const;
  void set_total_wr_latency(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 rd_byte_count = 4;
  bool has_rd_byte_count() const;
  void clear_rd_byte_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_byte_count() const;
  void set_rd_byte_count(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 rd_trans_count = 5;
  bool has_rd_trans_count() const;
  void clear_rd_trans_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_trans_count() const;
  void set_rd_trans_count(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 total_rd_latency = 6;
  bool has_total_rd_latency() const;
  void clear_total_rd_latency();
  ::PROTOBUF_NAMESPACE_ID::uint32 total_rd_latency() const;
  void set_total_rd_latency(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadCounters_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_byte_count_;
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_trans_count_;
  ::PROTOBUF_NAMESPACE_ID::uint32 total_wr_latency_;
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_byte_count_;
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_trans_count_;
  ::PROTOBUF_NAMESPACE_ID::uint32 total_rd_latency_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonGetTraceCount_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonGetTraceCount_call) */ {
 public:
  xclPerfMonGetTraceCount_call();
  virtual ~xclPerfMonGetTraceCount_call();

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

  inline xclPerfMonGetTraceCount_call& operator=(const xclPerfMonGetTraceCount_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonGetTraceCount_call& operator=(xclPerfMonGetTraceCount_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonGetTraceCount_call& default_instance();

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

  friend void swap(xclPerfMonGetTraceCount_call& a, xclPerfMonGetTraceCount_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonGetTraceCount_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonGetTraceCount_call* New() const final {
    return CreateMaybeMessage<xclPerfMonGetTraceCount_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonGetTraceCount_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonGetTraceCount_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotnameFieldNumber = 2,
    kAckFieldNumber = 1,
    kAccelFieldNumber = 3,
  };
  // optional string slotname = 2;
  bool has_slotname() const;
  void clear_slotname();
  const std::string& slotname() const;
  void set_slotname(const std::string& value);
  void set_slotname(std::string&& value);
  void set_slotname(const char* value);
  void set_slotname(const char* value, size_t size);
  std::string* mutable_slotname();
  std::string* release_slotname();
  void set_allocated_slotname(std::string* slotname);

  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // optional bool accel = 3;
  bool has_accel() const;
  void clear_accel();
  bool accel() const;
  void set_accel(bool value);

  // @@protoc_insertion_point(class_scope:xclPerfMonGetTraceCount_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slotname_;
  bool ack_;
  bool accel_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonGetTraceCount_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonGetTraceCount_response) */ {
 public:
  xclPerfMonGetTraceCount_response();
  virtual ~xclPerfMonGetTraceCount_response();

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

  inline xclPerfMonGetTraceCount_response& operator=(const xclPerfMonGetTraceCount_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonGetTraceCount_response& operator=(xclPerfMonGetTraceCount_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonGetTraceCount_response& default_instance();

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

  friend void swap(xclPerfMonGetTraceCount_response& a, xclPerfMonGetTraceCount_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonGetTraceCount_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonGetTraceCount_response* New() const final {
    return CreateMaybeMessage<xclPerfMonGetTraceCount_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonGetTraceCount_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonGetTraceCount_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNoOfSamplesFieldNumber = 1,
  };
  // optional uint32 no_of_samples = 1;
  bool has_no_of_samples() const;
  void clear_no_of_samples();
  ::PROTOBUF_NAMESPACE_ID::uint32 no_of_samples() const;
  void set_no_of_samples(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclPerfMonGetTraceCount_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 no_of_samples_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_call) */ {
 public:
  xclPerfMonReadTrace_call();
  virtual ~xclPerfMonReadTrace_call();

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

  inline xclPerfMonReadTrace_call& operator=(const xclPerfMonReadTrace_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_call& operator=(xclPerfMonReadTrace_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_call& default_instance();

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

  friend void swap(xclPerfMonReadTrace_call& a, xclPerfMonReadTrace_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_call* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotnameFieldNumber = 2,
    kAckFieldNumber = 1,
    kAccelFieldNumber = 3,
  };
  // optional string slotname = 2;
  bool has_slotname() const;
  void clear_slotname();
  const std::string& slotname() const;
  void set_slotname(const std::string& value);
  void set_slotname(std::string&& value);
  void set_slotname(const char* value);
  void set_slotname(const char* value, size_t size);
  std::string* mutable_slotname();
  std::string* release_slotname();
  void set_allocated_slotname(std::string* slotname);

  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // optional bool accel = 3;
  bool has_accel() const;
  void clear_accel();
  bool accel() const;
  void set_accel(bool value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slotname_;
  bool ack_;
  bool accel_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_response_events :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_response.events) */ {
 public:
  xclPerfMonReadTrace_response_events();
  virtual ~xclPerfMonReadTrace_response_events();

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

  inline xclPerfMonReadTrace_response_events& operator=(const xclPerfMonReadTrace_response_events& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_response_events& operator=(xclPerfMonReadTrace_response_events&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_response_events& default_instance();

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

  friend void swap(xclPerfMonReadTrace_response_events& a, xclPerfMonReadTrace_response_events& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_response_events* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_response_events* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_response_events>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_response_events* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_response.events";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAwlenFieldNumber = 1,
    kArlenFieldNumber = 2,
    kEventflagsFieldNumber = 3,
    kTimestampFieldNumber = 4,
    kHostTimestampFieldNumber = 5,
    kRdBytesFieldNumber = 6,
    kWrBytesFieldNumber = 7,
  };
  // optional uint32 awlen = 1;
  bool has_awlen() const;
  void clear_awlen();
  ::PROTOBUF_NAMESPACE_ID::uint32 awlen() const;
  void set_awlen(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 arlen = 2;
  bool has_arlen() const;
  void clear_arlen();
  ::PROTOBUF_NAMESPACE_ID::uint32 arlen() const;
  void set_arlen(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 eventflags = 3;
  bool has_eventflags() const;
  void clear_eventflags();
  ::PROTOBUF_NAMESPACE_ID::uint32 eventflags() const;
  void set_eventflags(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 timestamp = 4;
  bool has_timestamp() const;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint32 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 host_timestamp = 5;
  bool has_host_timestamp() const;
  void clear_host_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 host_timestamp() const;
  void set_host_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 rd_bytes = 6;
  bool has_rd_bytes() const;
  void clear_rd_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_bytes() const;
  void set_rd_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 wr_bytes = 7;
  bool has_wr_bytes() const;
  void clear_wr_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_bytes() const;
  void set_wr_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_response.events)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 awlen_;
  ::PROTOBUF_NAMESPACE_ID::uint32 arlen_;
  ::PROTOBUF_NAMESPACE_ID::uint32 eventflags_;
  ::PROTOBUF_NAMESPACE_ID::uint32 timestamp_;
  ::PROTOBUF_NAMESPACE_ID::uint64 host_timestamp_;
  ::PROTOBUF_NAMESPACE_ID::uint32 rd_bytes_;
  ::PROTOBUF_NAMESPACE_ID::uint32 wr_bytes_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_response) */ {
 public:
  xclPerfMonReadTrace_response();
  virtual ~xclPerfMonReadTrace_response();

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

  inline xclPerfMonReadTrace_response& operator=(const xclPerfMonReadTrace_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_response& operator=(xclPerfMonReadTrace_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_response& default_instance();

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

  friend void swap(xclPerfMonReadTrace_response& a, xclPerfMonReadTrace_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_response* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclPerfMonReadTrace_response_events events;

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

  enum : int {
    kOutputDataFieldNumber = 8,
  };
  // repeated .xclPerfMonReadTrace_response.events output_data = 8;
  int output_data_size() const;
  void clear_output_data();
  ::xclPerfMonReadTrace_response_events* mutable_output_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_response_events >*
      mutable_output_data();
  const ::xclPerfMonReadTrace_response_events& output_data(int index) const;
  ::xclPerfMonReadTrace_response_events* add_output_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_response_events >&
      output_data() const;

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_response_events > output_data_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class ddr_mem_msg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ddr_mem_msg) */ {
 public:
  ddr_mem_msg();
  virtual ~ddr_mem_msg();

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

  inline ddr_mem_msg& operator=(const ddr_mem_msg& from) {
    CopyFrom(from);
    return *this;
  }
  inline ddr_mem_msg& operator=(ddr_mem_msg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ddr_mem_msg& default_instance();

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

  friend void swap(ddr_mem_msg& a, ddr_mem_msg& b) {
    a.Swap(&b);
  }
  inline void Swap(ddr_mem_msg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ddr_mem_msg* New() const final {
    return CreateMaybeMessage<ddr_mem_msg>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ddr_mem_msg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ddr_mem_msg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 1,
    kStrbDataFieldNumber = 3,
    kSizeFieldNumber = 2,
    kFullsizeFieldNumber = 4,
  };
  // required bytes data = 1;
  bool has_data() const;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);

  // optional bytes strb_data = 3;
  bool has_strb_data() const;
  void clear_strb_data();
  const std::string& strb_data() const;
  void set_strb_data(const std::string& value);
  void set_strb_data(std::string&& value);
  void set_strb_data(const char* value);
  void set_strb_data(const void* value, size_t size);
  std::string* mutable_strb_data();
  std::string* release_strb_data();
  void set_allocated_strb_data(std::string* strb_data);

  // optional uint64 size = 2;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 fullsize = 4;
  bool has_fullsize() const;
  void clear_fullsize();
  ::PROTOBUF_NAMESPACE_ID::uint64 fullsize() const;
  void set_fullsize(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:ddr_mem_msg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr strb_data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 fullsize_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclGetDeviceTimestamp_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclGetDeviceTimestamp_call) */ {
 public:
  xclGetDeviceTimestamp_call();
  virtual ~xclGetDeviceTimestamp_call();

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

  inline xclGetDeviceTimestamp_call& operator=(const xclGetDeviceTimestamp_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclGetDeviceTimestamp_call& operator=(xclGetDeviceTimestamp_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclGetDeviceTimestamp_call& default_instance();

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

  friend void swap(xclGetDeviceTimestamp_call& a, xclGetDeviceTimestamp_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclGetDeviceTimestamp_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclGetDeviceTimestamp_call* New() const final {
    return CreateMaybeMessage<xclGetDeviceTimestamp_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclGetDeviceTimestamp_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclGetDeviceTimestamp_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclGetDeviceTimestamp_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclGetDeviceTimestamp_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclGetDeviceTimestamp_response) */ {
 public:
  xclGetDeviceTimestamp_response();
  virtual ~xclGetDeviceTimestamp_response();

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

  inline xclGetDeviceTimestamp_response& operator=(const xclGetDeviceTimestamp_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclGetDeviceTimestamp_response& operator=(xclGetDeviceTimestamp_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclGetDeviceTimestamp_response& default_instance();

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

  friend void swap(xclGetDeviceTimestamp_response& a, xclGetDeviceTimestamp_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclGetDeviceTimestamp_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclGetDeviceTimestamp_response* New() const final {
    return CreateMaybeMessage<xclGetDeviceTimestamp_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclGetDeviceTimestamp_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclGetDeviceTimestamp_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDeviceTimestampFieldNumber = 1,
  };
  // required uint64 device_timestamp = 1;
  bool has_device_timestamp() const;
  void clear_device_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 device_timestamp() const;
  void set_device_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclGetDeviceTimestamp_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 device_timestamp_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadBusStatus_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadBusStatus_call) */ {
 public:
  xclReadBusStatus_call();
  virtual ~xclReadBusStatus_call();

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

  inline xclReadBusStatus_call& operator=(const xclReadBusStatus_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadBusStatus_call& operator=(xclReadBusStatus_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadBusStatus_call& default_instance();

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

  friend void swap(xclReadBusStatus_call& a, xclReadBusStatus_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadBusStatus_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadBusStatus_call* New() const final {
    return CreateMaybeMessage<xclReadBusStatus_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadBusStatus_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadBusStatus_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotNFieldNumber = 1,
  };
  // optional int32 slot_n = 1;
  bool has_slot_n() const;
  void clear_slot_n();
  ::PROTOBUF_NAMESPACE_ID::int32 slot_n() const;
  void set_slot_n(::PROTOBUF_NAMESPACE_ID::int32 value);

  // @@protoc_insertion_point(class_scope:xclReadBusStatus_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 slot_n_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadBusStatus_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadBusStatus_response) */ {
 public:
  xclReadBusStatus_response();
  virtual ~xclReadBusStatus_response();

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

  inline xclReadBusStatus_response& operator=(const xclReadBusStatus_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadBusStatus_response& operator=(xclReadBusStatus_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadBusStatus_response& default_instance();

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

  friend void swap(xclReadBusStatus_response& a, xclReadBusStatus_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadBusStatus_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadBusStatus_response* New() const final {
    return CreateMaybeMessage<xclReadBusStatus_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadBusStatus_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadBusStatus_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kUncompleteRdCyclesFieldNumber = 1,
    kUncompleteWrCyclesFieldNumber = 2,
    kIdleBusCyclesFieldNumber = 3,
    kUncompleteRdIdFieldNumber = 4,
    kUncompleteWrIdFieldNumber = 5,
  };
  // optional uint64 uncomplete_rd_cycles = 1;
  bool has_uncomplete_rd_cycles() const;
  void clear_uncomplete_rd_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_rd_cycles() const;
  void set_uncomplete_rd_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 uncomplete_wr_cycles = 2;
  bool has_uncomplete_wr_cycles() const;
  void clear_uncomplete_wr_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_wr_cycles() const;
  void set_uncomplete_wr_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 idle_bus_cycles = 3;
  bool has_idle_bus_cycles() const;
  void clear_idle_bus_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 idle_bus_cycles() const;
  void set_idle_bus_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 uncomplete_rd_id = 4;
  bool has_uncomplete_rd_id() const;
  void clear_uncomplete_rd_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_rd_id() const;
  void set_uncomplete_rd_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 uncomplete_wr_id = 5;
  bool has_uncomplete_wr_id() const;
  void clear_uncomplete_wr_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_wr_id() const;
  void set_uncomplete_wr_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclReadBusStatus_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_rd_cycles_;
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_wr_cycles_;
  ::PROTOBUF_NAMESPACE_ID::uint64 idle_bus_cycles_;
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_rd_id_;
  ::PROTOBUF_NAMESPACE_ID::uint64 uncomplete_wr_id_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclGetDebugMessages_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclGetDebugMessages_call) */ {
 public:
  xclGetDebugMessages_call();
  virtual ~xclGetDebugMessages_call();

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

  inline xclGetDebugMessages_call& operator=(const xclGetDebugMessages_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclGetDebugMessages_call& operator=(xclGetDebugMessages_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclGetDebugMessages_call& default_instance();

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

  friend void swap(xclGetDebugMessages_call& a, xclGetDebugMessages_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclGetDebugMessages_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclGetDebugMessages_call* New() const final {
    return CreateMaybeMessage<xclGetDebugMessages_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclGetDebugMessages_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclGetDebugMessages_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
    kForceFieldNumber = 2,
  };
  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // optional bool force = 2;
  bool has_force() const;
  void clear_force();
  bool force() const;
  void set_force(bool value);

  // @@protoc_insertion_point(class_scope:xclGetDebugMessages_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  bool force_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclGetDebugMessages_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclGetDebugMessages_response) */ {
 public:
  xclGetDebugMessages_response();
  virtual ~xclGetDebugMessages_response();

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

  inline xclGetDebugMessages_response& operator=(const xclGetDebugMessages_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclGetDebugMessages_response& operator=(xclGetDebugMessages_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclGetDebugMessages_response& default_instance();

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

  friend void swap(xclGetDebugMessages_response& a, xclGetDebugMessages_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclGetDebugMessages_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclGetDebugMessages_response* New() const final {
    return CreateMaybeMessage<xclGetDebugMessages_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclGetDebugMessages_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclGetDebugMessages_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDisplayMsgsFieldNumber = 1,
    kLogMsgsFieldNumber = 2,
    kStopMsgsFieldNumber = 3,
  };
  // optional bytes display_msgs = 1;
  bool has_display_msgs() const;
  void clear_display_msgs();
  const std::string& display_msgs() const;
  void set_display_msgs(const std::string& value);
  void set_display_msgs(std::string&& value);
  void set_display_msgs(const char* value);
  void set_display_msgs(const void* value, size_t size);
  std::string* mutable_display_msgs();
  std::string* release_display_msgs();
  void set_allocated_display_msgs(std::string* display_msgs);

  // optional bytes log_msgs = 2;
  bool has_log_msgs() const;
  void clear_log_msgs();
  const std::string& log_msgs() const;
  void set_log_msgs(const std::string& value);
  void set_log_msgs(std::string&& value);
  void set_log_msgs(const char* value);
  void set_log_msgs(const void* value, size_t size);
  std::string* mutable_log_msgs();
  std::string* release_log_msgs();
  void set_allocated_log_msgs(std::string* log_msgs);

  // optional bytes stop_msgs = 3;
  bool has_stop_msgs() const;
  void clear_stop_msgs();
  const std::string& stop_msgs() const;
  void set_stop_msgs(const std::string& value);
  void set_stop_msgs(std::string&& value);
  void set_stop_msgs(const char* value);
  void set_stop_msgs(const void* value, size_t size);
  std::string* mutable_stop_msgs();
  std::string* release_stop_msgs();
  void set_allocated_stop_msgs(std::string* stop_msgs);

  // @@protoc_insertion_point(class_scope:xclGetDebugMessages_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr display_msgs_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_msgs_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stop_msgs_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclImportBO_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclImportBO_call) */ {
 public:
  xclImportBO_call();
  virtual ~xclImportBO_call();

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

  inline xclImportBO_call& operator=(const xclImportBO_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclImportBO_call& operator=(xclImportBO_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclImportBO_call& default_instance();

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

  friend void swap(xclImportBO_call& a, xclImportBO_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclImportBO_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclImportBO_call* New() const final {
    return CreateMaybeMessage<xclImportBO_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclImportBO_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclImportBO_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDstFilenameFieldNumber = 1,
    kOffsetFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // optional string dst_filename = 1;
  bool has_dst_filename() const;
  void clear_dst_filename();
  const std::string& dst_filename() const;
  void set_dst_filename(const std::string& value);
  void set_dst_filename(std::string&& value);
  void set_dst_filename(const char* value);
  void set_dst_filename(const char* value, size_t size);
  std::string* mutable_dst_filename();
  std::string* release_dst_filename();
  void set_allocated_dst_filename(std::string* dst_filename);

  // optional uint64 offset = 2;
  bool has_offset() const;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::uint64 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclImportBO_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dst_filename_;
  ::PROTOBUF_NAMESPACE_ID::uint64 offset_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclImportBO_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclImportBO_response) */ {
 public:
  xclImportBO_response();
  virtual ~xclImportBO_response();

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

  inline xclImportBO_response& operator=(const xclImportBO_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclImportBO_response& operator=(xclImportBO_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclImportBO_response& default_instance();

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

  friend void swap(xclImportBO_response& a, xclImportBO_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclImportBO_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclImportBO_response* New() const final {
    return CreateMaybeMessage<xclImportBO_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclImportBO_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclImportBO_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclImportBO_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBO_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBO_call) */ {
 public:
  xclCopyBO_call();
  virtual ~xclCopyBO_call();

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

  inline xclCopyBO_call& operator=(const xclCopyBO_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBO_call& operator=(xclCopyBO_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBO_call& default_instance();

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

  friend void swap(xclCopyBO_call& a, xclCopyBO_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBO_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBO_call* New() const final {
    return CreateMaybeMessage<xclCopyBO_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBO_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBO_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDstFilenameFieldNumber = 2,
    kSrcHandleFieldNumber = 1,
    kSizeFieldNumber = 3,
    kSrcOffsetFieldNumber = 4,
    kDstOffsetFieldNumber = 5,
  };
  // optional string dst_filename = 2;
  bool has_dst_filename() const;
  void clear_dst_filename();
  const std::string& dst_filename() const;
  void set_dst_filename(const std::string& value);
  void set_dst_filename(std::string&& value);
  void set_dst_filename(const char* value);
  void set_dst_filename(const char* value, size_t size);
  std::string* mutable_dst_filename();
  std::string* release_dst_filename();
  void set_allocated_dst_filename(std::string* dst_filename);

  // optional uint64 src_handle = 1;
  bool has_src_handle() const;
  void clear_src_handle();
  ::PROTOBUF_NAMESPACE_ID::uint64 src_handle() const;
  void set_src_handle(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 src_offset = 4;
  bool has_src_offset() const;
  void clear_src_offset();
  ::PROTOBUF_NAMESPACE_ID::uint64 src_offset() const;
  void set_src_offset(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 dst_offset = 5;
  bool has_dst_offset() const;
  void clear_dst_offset();
  ::PROTOBUF_NAMESPACE_ID::uint64 dst_offset() const;
  void set_dst_offset(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclCopyBO_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dst_filename_;
  ::PROTOBUF_NAMESPACE_ID::uint64 src_handle_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 src_offset_;
  ::PROTOBUF_NAMESPACE_ID::uint64 dst_offset_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCopyBO_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCopyBO_response) */ {
 public:
  xclCopyBO_response();
  virtual ~xclCopyBO_response();

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

  inline xclCopyBO_response& operator=(const xclCopyBO_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCopyBO_response& operator=(xclCopyBO_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCopyBO_response& default_instance();

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

  friend void swap(xclCopyBO_response& a, xclCopyBO_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCopyBO_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCopyBO_response* New() const final {
    return CreateMaybeMessage<xclCopyBO_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCopyBO_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCopyBO_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAckFieldNumber = 1,
  };
  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclCopyBO_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCreateQueue_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCreateQueue_call) */ {
 public:
  xclCreateQueue_call();
  virtual ~xclCreateQueue_call();

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

  inline xclCreateQueue_call& operator=(const xclCreateQueue_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCreateQueue_call& operator=(xclCreateQueue_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCreateQueue_call& default_instance();

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

  friend void swap(xclCreateQueue_call& a, xclCreateQueue_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCreateQueue_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCreateQueue_call* New() const final {
    return CreateMaybeMessage<xclCreateQueue_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCreateQueue_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCreateQueue_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWriteFieldNumber = 1,
    kTypeFieldNumber = 2,
    kStateFieldNumber = 3,
    kRouteFieldNumber = 4,
    kFlowFieldNumber = 5,
    kQsizeFieldNumber = 6,
    kDescSizeFieldNumber = 7,
    kFlagsFieldNumber = 8,
  };
  // optional bool write = 1;
  bool has_write() const;
  void clear_write();
  bool write() const;
  void set_write(bool value);

  // optional uint32 type = 2;
  bool has_type() const;
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 state = 3;
  bool has_state() const;
  void clear_state();
  ::PROTOBUF_NAMESPACE_ID::uint32 state() const;
  void set_state(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 route = 4;
  bool has_route() const;
  void clear_route();
  ::PROTOBUF_NAMESPACE_ID::uint32 route() const;
  void set_route(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 flow = 5;
  bool has_flow() const;
  void clear_flow();
  ::PROTOBUF_NAMESPACE_ID::uint64 flow() const;
  void set_flow(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 qsize = 6;
  bool has_qsize() const;
  void clear_qsize();
  ::PROTOBUF_NAMESPACE_ID::uint32 qsize() const;
  void set_qsize(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 desc_size = 7;
  bool has_desc_size() const;
  void clear_desc_size();
  ::PROTOBUF_NAMESPACE_ID::uint32 desc_size() const;
  void set_desc_size(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 flags = 8;
  bool has_flags() const;
  void clear_flags();
  ::PROTOBUF_NAMESPACE_ID::uint64 flags() const;
  void set_flags(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclCreateQueue_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool write_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 state_;
  ::PROTOBUF_NAMESPACE_ID::uint32 route_;
  ::PROTOBUF_NAMESPACE_ID::uint64 flow_;
  ::PROTOBUF_NAMESPACE_ID::uint32 qsize_;
  ::PROTOBUF_NAMESPACE_ID::uint32 desc_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 flags_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclCreateQueue_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclCreateQueue_response) */ {
 public:
  xclCreateQueue_response();
  virtual ~xclCreateQueue_response();

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

  inline xclCreateQueue_response& operator=(const xclCreateQueue_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclCreateQueue_response& operator=(xclCreateQueue_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclCreateQueue_response& default_instance();

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

  friend void swap(xclCreateQueue_response& a, xclCreateQueue_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclCreateQueue_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclCreateQueue_response* New() const final {
    return CreateMaybeMessage<xclCreateQueue_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclCreateQueue_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclCreateQueue_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kQHandleFieldNumber = 1,
  };
  // optional uint64 q_handle = 1;
  bool has_q_handle() const;
  void clear_q_handle();
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle() const;
  void set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclCreateQueue_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteQueue_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteQueue_call) */ {
 public:
  xclWriteQueue_call();
  virtual ~xclWriteQueue_call();

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

  inline xclWriteQueue_call& operator=(const xclWriteQueue_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteQueue_call& operator=(xclWriteQueue_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteQueue_call& default_instance();

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

  friend void swap(xclWriteQueue_call& a, xclWriteQueue_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteQueue_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteQueue_call* New() const final {
    return CreateMaybeMessage<xclWriteQueue_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteQueue_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteQueue_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSrcFieldNumber = 2,
    kQHandleFieldNumber = 1,
    kSizeFieldNumber = 3,
    kReqFieldNumber = 4,
    kNonblockingFieldNumber = 5,
    kEotFieldNumber = 6,
  };
  // optional bytes src = 2;
  bool has_src() const;
  void clear_src();
  const std::string& src() const;
  void set_src(const std::string& value);
  void set_src(std::string&& value);
  void set_src(const char* value);
  void set_src(const void* value, size_t size);
  std::string* mutable_src();
  std::string* release_src();
  void set_allocated_src(std::string* src);

  // optional uint64 q_handle = 1;
  bool has_q_handle() const;
  void clear_q_handle();
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle() const;
  void set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 req = 4;
  bool has_req() const;
  void clear_req();
  ::PROTOBUF_NAMESPACE_ID::uint64 req() const;
  void set_req(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional bool nonblocking = 5;
  bool has_nonblocking() const;
  void clear_nonblocking();
  bool nonblocking() const;
  void set_nonblocking(bool value);

  // optional bool eot = 6;
  bool has_eot() const;
  void clear_eot();
  bool eot() const;
  void set_eot(bool value);

  // @@protoc_insertion_point(class_scope:xclWriteQueue_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr src_;
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 req_;
  bool nonblocking_;
  bool eot_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclWriteQueue_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclWriteQueue_response) */ {
 public:
  xclWriteQueue_response();
  virtual ~xclWriteQueue_response();

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

  inline xclWriteQueue_response& operator=(const xclWriteQueue_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclWriteQueue_response& operator=(xclWriteQueue_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclWriteQueue_response& default_instance();

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

  friend void swap(xclWriteQueue_response& a, xclWriteQueue_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclWriteQueue_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclWriteQueue_response* New() const final {
    return CreateMaybeMessage<xclWriteQueue_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclWriteQueue_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclWriteQueue_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWrittenSizeFieldNumber = 1,
  };
  // optional uint64 written_size = 1;
  bool has_written_size() const;
  void clear_written_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 written_size() const;
  void set_written_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclWriteQueue_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 written_size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadQueue_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadQueue_call) */ {
 public:
  xclReadQueue_call();
  virtual ~xclReadQueue_call();

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

  inline xclReadQueue_call& operator=(const xclReadQueue_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadQueue_call& operator=(xclReadQueue_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadQueue_call& default_instance();

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

  friend void swap(xclReadQueue_call& a, xclReadQueue_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadQueue_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadQueue_call* New() const final {
    return CreateMaybeMessage<xclReadQueue_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadQueue_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadQueue_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDestFieldNumber = 2,
    kQHandleFieldNumber = 1,
    kSizeFieldNumber = 3,
    kReqFieldNumber = 4,
    kNonblockingFieldNumber = 5,
    kEotFieldNumber = 6,
  };
  // optional bytes dest = 2;
  bool has_dest() const;
  void clear_dest();
  const std::string& dest() const;
  void set_dest(const std::string& value);
  void set_dest(std::string&& value);
  void set_dest(const char* value);
  void set_dest(const void* value, size_t size);
  std::string* mutable_dest();
  std::string* release_dest();
  void set_allocated_dest(std::string* dest);

  // optional uint64 q_handle = 1;
  bool has_q_handle() const;
  void clear_q_handle();
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle() const;
  void set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 size = 3;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 req = 4;
  bool has_req() const;
  void clear_req();
  ::PROTOBUF_NAMESPACE_ID::uint64 req() const;
  void set_req(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional bool nonblocking = 5;
  bool has_nonblocking() const;
  void clear_nonblocking();
  bool nonblocking() const;
  void set_nonblocking(bool value);

  // optional bool eot = 6;
  bool has_eot() const;
  void clear_eot();
  bool eot() const;
  void set_eot(bool value);

  // @@protoc_insertion_point(class_scope:xclReadQueue_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 req_;
  bool nonblocking_;
  bool eot_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclReadQueue_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclReadQueue_response) */ {
 public:
  xclReadQueue_response();
  virtual ~xclReadQueue_response();

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

  inline xclReadQueue_response& operator=(const xclReadQueue_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclReadQueue_response& operator=(xclReadQueue_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclReadQueue_response& default_instance();

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

  friend void swap(xclReadQueue_response& a, xclReadQueue_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclReadQueue_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclReadQueue_response* New() const final {
    return CreateMaybeMessage<xclReadQueue_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclReadQueue_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclReadQueue_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDestFieldNumber = 1,
    kSizeFieldNumber = 2,
  };
  // optional bytes dest = 1;
  bool has_dest() const;
  void clear_dest();
  const std::string& dest() const;
  void set_dest(const std::string& value);
  void set_dest(std::string&& value);
  void set_dest(const char* value);
  void set_dest(const void* value, size_t size);
  std::string* mutable_dest();
  std::string* release_dest();
  void set_allocated_dest(std::string* dest);

  // optional uint64 size = 2;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclReadQueue_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPollCompletion_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPollCompletion_call) */ {
 public:
  xclPollCompletion_call();
  virtual ~xclPollCompletion_call();

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

  inline xclPollCompletion_call& operator=(const xclPollCompletion_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPollCompletion_call& operator=(xclPollCompletion_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPollCompletion_call& default_instance();

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

  friend void swap(xclPollCompletion_call& a, xclPollCompletion_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPollCompletion_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPollCompletion_call* New() const final {
    return CreateMaybeMessage<xclPollCompletion_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPollCompletion_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPollCompletion_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kReqFieldNumber = 1,
  };
  // optional uint64 req = 1;
  bool has_req() const;
  void clear_req();
  ::PROTOBUF_NAMESPACE_ID::uint64 req() const;
  void set_req(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclPollCompletion_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 req_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPollCompletion_response_request :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPollCompletion_response.request) */ {
 public:
  xclPollCompletion_response_request();
  virtual ~xclPollCompletion_response_request();

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

  inline xclPollCompletion_response_request& operator=(const xclPollCompletion_response_request& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPollCompletion_response_request& operator=(xclPollCompletion_response_request&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPollCompletion_response_request& default_instance();

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

  friend void swap(xclPollCompletion_response_request& a, xclPollCompletion_response_request& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPollCompletion_response_request* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPollCompletion_response_request* New() const final {
    return CreateMaybeMessage<xclPollCompletion_response_request>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPollCompletion_response_request* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPollCompletion_response.request";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDestFieldNumber = 1,
    kSizeFieldNumber = 2,
  };
  // optional bytes dest = 1;
  bool has_dest() const;
  void clear_dest();
  const std::string& dest() const;
  void set_dest(const std::string& value);
  void set_dest(std::string&& value);
  void set_dest(const char* value);
  void set_dest(const void* value, size_t size);
  std::string* mutable_dest();
  std::string* release_dest();
  void set_allocated_dest(std::string* dest);

  // optional uint64 size = 2;
  bool has_size() const;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclPollCompletion_response.request)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPollCompletion_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPollCompletion_response) */ {
 public:
  xclPollCompletion_response();
  virtual ~xclPollCompletion_response();

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

  inline xclPollCompletion_response& operator=(const xclPollCompletion_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPollCompletion_response& operator=(xclPollCompletion_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPollCompletion_response& default_instance();

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

  friend void swap(xclPollCompletion_response& a, xclPollCompletion_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPollCompletion_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPollCompletion_response* New() const final {
    return CreateMaybeMessage<xclPollCompletion_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPollCompletion_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPollCompletion_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclPollCompletion_response_request request;

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

  enum : int {
    kFullrequestFieldNumber = 3,
  };
  // repeated .xclPollCompletion_response.request fullrequest = 3;
  int fullrequest_size() const;
  void clear_fullrequest();
  ::xclPollCompletion_response_request* mutable_fullrequest(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPollCompletion_response_request >*
      mutable_fullrequest();
  const ::xclPollCompletion_response_request& fullrequest(int index) const;
  ::xclPollCompletion_response_request* add_fullrequest();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPollCompletion_response_request >&
      fullrequest() const;

  // @@protoc_insertion_point(class_scope:xclPollCompletion_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPollCompletion_response_request > fullrequest_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclDestroyQueue_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclDestroyQueue_call) */ {
 public:
  xclDestroyQueue_call();
  virtual ~xclDestroyQueue_call();

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

  inline xclDestroyQueue_call& operator=(const xclDestroyQueue_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclDestroyQueue_call& operator=(xclDestroyQueue_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclDestroyQueue_call& default_instance();

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

  friend void swap(xclDestroyQueue_call& a, xclDestroyQueue_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclDestroyQueue_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclDestroyQueue_call* New() const final {
    return CreateMaybeMessage<xclDestroyQueue_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclDestroyQueue_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclDestroyQueue_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kQHandleFieldNumber = 1,
  };
  // optional uint64 q_handle = 1;
  bool has_q_handle() const;
  void clear_q_handle();
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle() const;
  void set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclDestroyQueue_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 q_handle_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclDestroyQueue_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclDestroyQueue_response) */ {
 public:
  xclDestroyQueue_response();
  virtual ~xclDestroyQueue_response();

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

  inline xclDestroyQueue_response& operator=(const xclDestroyQueue_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclDestroyQueue_response& operator=(xclDestroyQueue_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclDestroyQueue_response& default_instance();

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

  friend void swap(xclDestroyQueue_response& a, xclDestroyQueue_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclDestroyQueue_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclDestroyQueue_response* New() const final {
    return CreateMaybeMessage<xclDestroyQueue_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclDestroyQueue_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclDestroyQueue_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSuccessFieldNumber = 1,
  };
  // optional bool success = 1;
  bool has_success() const;
  void clear_success();
  bool success() const;
  void set_success(bool value);

  // @@protoc_insertion_point(class_scope:xclDestroyQueue_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool success_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetupInstance_call_argflowpair :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetupInstance_call.argflowpair) */ {
 public:
  xclSetupInstance_call_argflowpair();
  virtual ~xclSetupInstance_call_argflowpair();

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

  inline xclSetupInstance_call_argflowpair& operator=(const xclSetupInstance_call_argflowpair& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetupInstance_call_argflowpair& operator=(xclSetupInstance_call_argflowpair&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetupInstance_call_argflowpair& default_instance();

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

  friend void swap(xclSetupInstance_call_argflowpair& a, xclSetupInstance_call_argflowpair& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetupInstance_call_argflowpair* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetupInstance_call_argflowpair* New() const final {
    return CreateMaybeMessage<xclSetupInstance_call_argflowpair>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetupInstance_call_argflowpair* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetupInstance_call.argflowpair";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTagFieldNumber = 4,
    kArgFieldNumber = 2,
    kFlowFieldNumber = 3,
  };
  // optional string tag = 4;
  bool has_tag() const;
  void clear_tag();
  const std::string& tag() const;
  void set_tag(const std::string& value);
  void set_tag(std::string&& value);
  void set_tag(const char* value);
  void set_tag(const char* value, size_t size);
  std::string* mutable_tag();
  std::string* release_tag();
  void set_allocated_tag(std::string* tag);

  // optional uint64 arg = 2;
  bool has_arg() const;
  void clear_arg();
  ::PROTOBUF_NAMESPACE_ID::uint64 arg() const;
  void set_arg(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 flow = 3;
  bool has_flow() const;
  void clear_flow();
  ::PROTOBUF_NAMESPACE_ID::uint64 flow() const;
  void set_flow(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclSetupInstance_call.argflowpair)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
  ::PROTOBUF_NAMESPACE_ID::uint64 arg_;
  ::PROTOBUF_NAMESPACE_ID::uint64 flow_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetupInstance_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetupInstance_call) */ {
 public:
  xclSetupInstance_call();
  virtual ~xclSetupInstance_call();

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

  inline xclSetupInstance_call& operator=(const xclSetupInstance_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetupInstance_call& operator=(xclSetupInstance_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetupInstance_call& default_instance();

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

  friend void swap(xclSetupInstance_call& a, xclSetupInstance_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetupInstance_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetupInstance_call* New() const final {
    return CreateMaybeMessage<xclSetupInstance_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetupInstance_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetupInstance_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclSetupInstance_call_argflowpair argflowpair;

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

  enum : int {
    kSetupFieldNumber = 5,
    kRouteFieldNumber = 1,
  };
  // repeated .xclSetupInstance_call.argflowpair setup = 5;
  int setup_size() const;
  void clear_setup();
  ::xclSetupInstance_call_argflowpair* mutable_setup(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetupInstance_call_argflowpair >*
      mutable_setup();
  const ::xclSetupInstance_call_argflowpair& setup(int index) const;
  ::xclSetupInstance_call_argflowpair* add_setup();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetupInstance_call_argflowpair >&
      setup() const;

  // optional uint64 route = 1;
  bool has_route() const;
  void clear_route();
  ::PROTOBUF_NAMESPACE_ID::uint64 route() const;
  void set_route(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclSetupInstance_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetupInstance_call_argflowpair > setup_;
  ::PROTOBUF_NAMESPACE_ID::uint64 route_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclSetupInstance_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclSetupInstance_response) */ {
 public:
  xclSetupInstance_response();
  virtual ~xclSetupInstance_response();

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

  inline xclSetupInstance_response& operator=(const xclSetupInstance_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclSetupInstance_response& operator=(xclSetupInstance_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclSetupInstance_response& default_instance();

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

  friend void swap(xclSetupInstance_response& a, xclSetupInstance_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclSetupInstance_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclSetupInstance_response* New() const final {
    return CreateMaybeMessage<xclSetupInstance_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclSetupInstance_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclSetupInstance_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSuccessFieldNumber = 1,
  };
  // optional bool success = 1;
  bool has_success() const;
  void clear_success();
  bool success() const;
  void set_success(bool value);

  // @@protoc_insertion_point(class_scope:xclSetupInstance_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool success_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadCounters_Streaming_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadCounters_Streaming_call) */ {
 public:
  xclPerfMonReadCounters_Streaming_call();
  virtual ~xclPerfMonReadCounters_Streaming_call();

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

  inline xclPerfMonReadCounters_Streaming_call& operator=(const xclPerfMonReadCounters_Streaming_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadCounters_Streaming_call& operator=(xclPerfMonReadCounters_Streaming_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadCounters_Streaming_call& default_instance();

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

  friend void swap(xclPerfMonReadCounters_Streaming_call& a, xclPerfMonReadCounters_Streaming_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadCounters_Streaming_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadCounters_Streaming_call* New() const final {
    return CreateMaybeMessage<xclPerfMonReadCounters_Streaming_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadCounters_Streaming_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadCounters_Streaming_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotnameFieldNumber = 1,
  };
  // required string slotname = 1;
  bool has_slotname() const;
  void clear_slotname();
  const std::string& slotname() const;
  void set_slotname(const std::string& value);
  void set_slotname(std::string&& value);
  void set_slotname(const char* value);
  void set_slotname(const char* value, size_t size);
  std::string* mutable_slotname();
  std::string* release_slotname();
  void set_allocated_slotname(std::string* slotname);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadCounters_Streaming_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slotname_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadCounters_Streaming_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadCounters_Streaming_response) */ {
 public:
  xclPerfMonReadCounters_Streaming_response();
  virtual ~xclPerfMonReadCounters_Streaming_response();

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

  inline xclPerfMonReadCounters_Streaming_response& operator=(const xclPerfMonReadCounters_Streaming_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadCounters_Streaming_response& operator=(xclPerfMonReadCounters_Streaming_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadCounters_Streaming_response& default_instance();

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

  friend void swap(xclPerfMonReadCounters_Streaming_response& a, xclPerfMonReadCounters_Streaming_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadCounters_Streaming_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadCounters_Streaming_response* New() const final {
    return CreateMaybeMessage<xclPerfMonReadCounters_Streaming_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadCounters_Streaming_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadCounters_Streaming_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStrNumTranxFieldNumber = 7,
    kStrDataBytesFieldNumber = 8,
    kStrBusyCyclesFieldNumber = 9,
    kStrStallCyclesFieldNumber = 10,
    kStrStarveCyclesFieldNumber = 11,
  };
  // optional uint64 str_num_tranx = 7;
  bool has_str_num_tranx() const;
  void clear_str_num_tranx();
  ::PROTOBUF_NAMESPACE_ID::uint64 str_num_tranx() const;
  void set_str_num_tranx(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 str_data_bytes = 8;
  bool has_str_data_bytes() const;
  void clear_str_data_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint64 str_data_bytes() const;
  void set_str_data_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 str_busy_cycles = 9;
  bool has_str_busy_cycles() const;
  void clear_str_busy_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 str_busy_cycles() const;
  void set_str_busy_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 str_stall_cycles = 10;
  bool has_str_stall_cycles() const;
  void clear_str_stall_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 str_stall_cycles() const;
  void set_str_stall_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 str_starve_cycles = 11;
  bool has_str_starve_cycles() const;
  void clear_str_starve_cycles();
  ::PROTOBUF_NAMESPACE_ID::uint64 str_starve_cycles() const;
  void set_str_starve_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadCounters_Streaming_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 str_num_tranx_;
  ::PROTOBUF_NAMESPACE_ID::uint64 str_data_bytes_;
  ::PROTOBUF_NAMESPACE_ID::uint64 str_busy_cycles_;
  ::PROTOBUF_NAMESPACE_ID::uint64 str_stall_cycles_;
  ::PROTOBUF_NAMESPACE_ID::uint64 str_starve_cycles_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_Streaming_call :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_Streaming_call) */ {
 public:
  xclPerfMonReadTrace_Streaming_call();
  virtual ~xclPerfMonReadTrace_Streaming_call();

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

  inline xclPerfMonReadTrace_Streaming_call& operator=(const xclPerfMonReadTrace_Streaming_call& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_Streaming_call& operator=(xclPerfMonReadTrace_Streaming_call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_Streaming_call& default_instance();

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

  friend void swap(xclPerfMonReadTrace_Streaming_call& a, xclPerfMonReadTrace_Streaming_call& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_Streaming_call* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_Streaming_call* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_Streaming_call>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_Streaming_call* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_Streaming_call";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSlotnameFieldNumber = 2,
    kAckFieldNumber = 1,
  };
  // optional string slotname = 2;
  bool has_slotname() const;
  void clear_slotname();
  const std::string& slotname() const;
  void set_slotname(const std::string& value);
  void set_slotname(std::string&& value);
  void set_slotname(const char* value);
  void set_slotname(const char* value, size_t size);
  std::string* mutable_slotname();
  std::string* release_slotname();
  void set_allocated_slotname(std::string* slotname);

  // optional bool ack = 1;
  bool has_ack() const;
  void clear_ack();
  bool ack() const;
  void set_ack(bool value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_Streaming_call)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slotname_;
  bool ack_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_Streaming_response_events :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_Streaming_response.events) */ {
 public:
  xclPerfMonReadTrace_Streaming_response_events();
  virtual ~xclPerfMonReadTrace_Streaming_response_events();

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

  inline xclPerfMonReadTrace_Streaming_response_events& operator=(const xclPerfMonReadTrace_Streaming_response_events& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_Streaming_response_events& operator=(xclPerfMonReadTrace_Streaming_response_events&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_Streaming_response_events& default_instance();

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

  friend void swap(xclPerfMonReadTrace_Streaming_response_events& a, xclPerfMonReadTrace_Streaming_response_events& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_Streaming_response_events* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_Streaming_response_events* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_Streaming_response_events>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_Streaming_response_events* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_Streaming_response.events";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kEventflagsFieldNumber = 3,
    kTimestampFieldNumber = 4,
    kHostTimestampFieldNumber = 5,
  };
  // optional uint32 eventflags = 3;
  bool has_eventflags() const;
  void clear_eventflags();
  ::PROTOBUF_NAMESPACE_ID::uint32 eventflags() const;
  void set_eventflags(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 timestamp = 4;
  bool has_timestamp() const;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint32 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 host_timestamp = 5;
  bool has_host_timestamp() const;
  void clear_host_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 host_timestamp() const;
  void set_host_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_Streaming_response.events)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 eventflags_;
  ::PROTOBUF_NAMESPACE_ID::uint32 timestamp_;
  ::PROTOBUF_NAMESPACE_ID::uint64 host_timestamp_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class xclPerfMonReadTrace_Streaming_response :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xclPerfMonReadTrace_Streaming_response) */ {
 public:
  xclPerfMonReadTrace_Streaming_response();
  virtual ~xclPerfMonReadTrace_Streaming_response();

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

  inline xclPerfMonReadTrace_Streaming_response& operator=(const xclPerfMonReadTrace_Streaming_response& from) {
    CopyFrom(from);
    return *this;
  }
  inline xclPerfMonReadTrace_Streaming_response& operator=(xclPerfMonReadTrace_Streaming_response&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const xclPerfMonReadTrace_Streaming_response& default_instance();

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

  friend void swap(xclPerfMonReadTrace_Streaming_response& a, xclPerfMonReadTrace_Streaming_response& b) {
    a.Swap(&b);
  }
  inline void Swap(xclPerfMonReadTrace_Streaming_response* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline xclPerfMonReadTrace_Streaming_response* New() const final {
    return CreateMaybeMessage<xclPerfMonReadTrace_Streaming_response>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(xclPerfMonReadTrace_Streaming_response* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xclPerfMonReadTrace_Streaming_response";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_rpc_5fmessages_2eproto);
    return ::descriptor_table_rpc_5fmessages_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef xclPerfMonReadTrace_Streaming_response_events events;

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

  enum : int {
    kOutputDataFieldNumber = 8,
  };
  // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
  int output_data_size() const;
  void clear_output_data();
  ::xclPerfMonReadTrace_Streaming_response_events* mutable_output_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_Streaming_response_events >*
      mutable_output_data();
  const ::xclPerfMonReadTrace_Streaming_response_events& output_data(int index) const;
  ::xclPerfMonReadTrace_Streaming_response_events* add_output_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_Streaming_response_events >&
      output_data() const;

  // @@protoc_insertion_point(class_scope:xclPerfMonReadTrace_Streaming_response)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_Streaming_response_events > output_data_;
  friend struct ::TableStruct_rpc_5fmessages_2eproto;
};
// ===================================================================


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

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

// required fixed64 size = 1;
inline bool call_packet_info::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void call_packet_info::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 call_packet_info::size() const {
  // @@protoc_insertion_point(field_get:call_packet_info.size)
  return size_;
}
inline void call_packet_info::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  size_ = value;
  // @@protoc_insertion_point(field_set:call_packet_info.size)
}

// optional fixed32 xcl_api = 2;
inline bool call_packet_info::has_xcl_api() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void call_packet_info::clear_xcl_api() {
  xcl_api_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 call_packet_info::xcl_api() const {
  // @@protoc_insertion_point(field_get:call_packet_info.xcl_api)
  return xcl_api_;
}
inline void call_packet_info::set_xcl_api(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  xcl_api_ = value;
  // @@protoc_insertion_point(field_set:call_packet_info.xcl_api)
}

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

// response_packet_info

// required fixed64 size = 1;
inline bool response_packet_info::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void response_packet_info::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 response_packet_info::size() const {
  // @@protoc_insertion_point(field_get:response_packet_info.size)
  return size_;
}
inline void response_packet_info::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  size_ = value;
  // @@protoc_insertion_point(field_set:response_packet_info.size)
}

// optional fixed32 xcl_api = 2;
inline bool response_packet_info::has_xcl_api() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void response_packet_info::clear_xcl_api() {
  xcl_api_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 response_packet_info::xcl_api() const {
  // @@protoc_insertion_point(field_get:response_packet_info.xcl_api)
  return xcl_api_;
}
inline void response_packet_info::set_xcl_api(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  xcl_api_ = value;
  // @@protoc_insertion_point(field_set:response_packet_info.xcl_api)
}

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

// xclSetEnvironment_call_namevaluepair

// optional string name = 1;
inline bool xclSetEnvironment_call_namevaluepair::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclSetEnvironment_call_namevaluepair::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclSetEnvironment_call_namevaluepair::name() const {
  // @@protoc_insertion_point(field_get:xclSetEnvironment_call.namevaluepair.name)
  return name_.GetNoArena();
}
inline void xclSetEnvironment_call_namevaluepair::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclSetEnvironment_call.namevaluepair.name)
}
inline void xclSetEnvironment_call_namevaluepair::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclSetEnvironment_call.namevaluepair.name)
}
inline void xclSetEnvironment_call_namevaluepair::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclSetEnvironment_call.namevaluepair.name)
}
inline void xclSetEnvironment_call_namevaluepair::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclSetEnvironment_call.namevaluepair.name)
}
inline std::string* xclSetEnvironment_call_namevaluepair::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclSetEnvironment_call.namevaluepair.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclSetEnvironment_call_namevaluepair::release_name() {
  // @@protoc_insertion_point(field_release:xclSetEnvironment_call.namevaluepair.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclSetEnvironment_call_namevaluepair::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:xclSetEnvironment_call.namevaluepair.name)
}

// optional string value = 2;
inline bool xclSetEnvironment_call_namevaluepair::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclSetEnvironment_call_namevaluepair::clear_value() {
  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& xclSetEnvironment_call_namevaluepair::value() const {
  // @@protoc_insertion_point(field_get:xclSetEnvironment_call.namevaluepair.value)
  return value_.GetNoArena();
}
inline void xclSetEnvironment_call_namevaluepair::set_value(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclSetEnvironment_call.namevaluepair.value)
}
inline void xclSetEnvironment_call_namevaluepair::set_value(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclSetEnvironment_call.namevaluepair.value)
}
inline void xclSetEnvironment_call_namevaluepair::set_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclSetEnvironment_call.namevaluepair.value)
}
inline void xclSetEnvironment_call_namevaluepair::set_value(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclSetEnvironment_call.namevaluepair.value)
}
inline std::string* xclSetEnvironment_call_namevaluepair::mutable_value() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:xclSetEnvironment_call.namevaluepair.value)
  return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclSetEnvironment_call_namevaluepair::release_value() {
  // @@protoc_insertion_point(field_release:xclSetEnvironment_call.namevaluepair.value)
  if (!has_value()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclSetEnvironment_call_namevaluepair::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:xclSetEnvironment_call.namevaluepair.value)
}

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

// xclSetEnvironment_call

// repeated .xclSetEnvironment_call.namevaluepair environment = 3;
inline int xclSetEnvironment_call::environment_size() const {
  return environment_.size();
}
inline void xclSetEnvironment_call::clear_environment() {
  environment_.Clear();
}
inline ::xclSetEnvironment_call_namevaluepair* xclSetEnvironment_call::mutable_environment(int index) {
  // @@protoc_insertion_point(field_mutable:xclSetEnvironment_call.environment)
  return environment_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetEnvironment_call_namevaluepair >*
xclSetEnvironment_call::mutable_environment() {
  // @@protoc_insertion_point(field_mutable_list:xclSetEnvironment_call.environment)
  return &environment_;
}
inline const ::xclSetEnvironment_call_namevaluepair& xclSetEnvironment_call::environment(int index) const {
  // @@protoc_insertion_point(field_get:xclSetEnvironment_call.environment)
  return environment_.Get(index);
}
inline ::xclSetEnvironment_call_namevaluepair* xclSetEnvironment_call::add_environment() {
  // @@protoc_insertion_point(field_add:xclSetEnvironment_call.environment)
  return environment_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetEnvironment_call_namevaluepair >&
xclSetEnvironment_call::environment() const {
  // @@protoc_insertion_point(field_list:xclSetEnvironment_call.environment)
  return environment_;
}

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

// xclSetEnvironment_response

// optional bool ack = 1;
inline bool xclSetEnvironment_response::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclSetEnvironment_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclSetEnvironment_response::ack() const {
  // @@protoc_insertion_point(field_get:xclSetEnvironment_response.ack)
  return ack_;
}
inline void xclSetEnvironment_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclSetEnvironment_response.ack)
}

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

// xclLoadBitstream_call_ddrbank

// optional uint64 size = 7;
inline bool xclLoadBitstream_call_ddrbank::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclLoadBitstream_call_ddrbank::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclLoadBitstream_call_ddrbank::size() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.ddrbank.size)
  return size_;
}
inline void xclLoadBitstream_call_ddrbank::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.ddrbank.size)
}

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

// xclLoadBitstream_call

// required bytes xmlfile = 1;
inline bool xclLoadBitstream_call::has_xmlfile() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclLoadBitstream_call::clear_xmlfile() {
  xmlfile_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclLoadBitstream_call::xmlfile() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.xmlfile)
  return xmlfile_.GetNoArena();
}
inline void xclLoadBitstream_call::set_xmlfile(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  xmlfile_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.xmlfile)
}
inline void xclLoadBitstream_call::set_xmlfile(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  xmlfile_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclLoadBitstream_call.xmlfile)
}
inline void xclLoadBitstream_call::set_xmlfile(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  xmlfile_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclLoadBitstream_call.xmlfile)
}
inline void xclLoadBitstream_call::set_xmlfile(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  xmlfile_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclLoadBitstream_call.xmlfile)
}
inline std::string* xclLoadBitstream_call::mutable_xmlfile() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.xmlfile)
  return xmlfile_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclLoadBitstream_call::release_xmlfile() {
  // @@protoc_insertion_point(field_release:xclLoadBitstream_call.xmlfile)
  if (!has_xmlfile()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return xmlfile_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclLoadBitstream_call::set_allocated_xmlfile(std::string* xmlfile) {
  if (xmlfile != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  xmlfile_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), xmlfile);
  // @@protoc_insertion_point(field_set_allocated:xclLoadBitstream_call.xmlfile)
}

// required bytes dlopenfilename = 2;
inline bool xclLoadBitstream_call::has_dlopenfilename() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclLoadBitstream_call::clear_dlopenfilename() {
  dlopenfilename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& xclLoadBitstream_call::dlopenfilename() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.dlopenfilename)
  return dlopenfilename_.GetNoArena();
}
inline void xclLoadBitstream_call::set_dlopenfilename(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  dlopenfilename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.dlopenfilename)
}
inline void xclLoadBitstream_call::set_dlopenfilename(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  dlopenfilename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclLoadBitstream_call.dlopenfilename)
}
inline void xclLoadBitstream_call::set_dlopenfilename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  dlopenfilename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclLoadBitstream_call.dlopenfilename)
}
inline void xclLoadBitstream_call::set_dlopenfilename(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  dlopenfilename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclLoadBitstream_call.dlopenfilename)
}
inline std::string* xclLoadBitstream_call::mutable_dlopenfilename() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.dlopenfilename)
  return dlopenfilename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclLoadBitstream_call::release_dlopenfilename() {
  // @@protoc_insertion_point(field_release:xclLoadBitstream_call.dlopenfilename)
  if (!has_dlopenfilename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return dlopenfilename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclLoadBitstream_call::set_allocated_dlopenfilename(std::string* dlopenfilename) {
  if (dlopenfilename != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  dlopenfilename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dlopenfilename);
  // @@protoc_insertion_point(field_set_allocated:xclLoadBitstream_call.dlopenfilename)
}

// required bytes devicename = 3;
inline bool xclLoadBitstream_call::has_devicename() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclLoadBitstream_call::clear_devicename() {
  devicename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& xclLoadBitstream_call::devicename() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.devicename)
  return devicename_.GetNoArena();
}
inline void xclLoadBitstream_call::set_devicename(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  devicename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.devicename)
}
inline void xclLoadBitstream_call::set_devicename(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  devicename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclLoadBitstream_call.devicename)
}
inline void xclLoadBitstream_call::set_devicename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  devicename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclLoadBitstream_call.devicename)
}
inline void xclLoadBitstream_call::set_devicename(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000004u;
  devicename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclLoadBitstream_call.devicename)
}
inline std::string* xclLoadBitstream_call::mutable_devicename() {
  _has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.devicename)
  return devicename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclLoadBitstream_call::release_devicename() {
  // @@protoc_insertion_point(field_release:xclLoadBitstream_call.devicename)
  if (!has_devicename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return devicename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclLoadBitstream_call::set_allocated_devicename(std::string* devicename) {
  if (devicename != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  devicename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), devicename);
  // @@protoc_insertion_point(field_set_allocated:xclLoadBitstream_call.devicename)
}

// required bytes devicedirectory = 4;
inline bool xclLoadBitstream_call::has_devicedirectory() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclLoadBitstream_call::clear_devicedirectory() {
  devicedirectory_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& xclLoadBitstream_call::devicedirectory() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.devicedirectory)
  return devicedirectory_.GetNoArena();
}
inline void xclLoadBitstream_call::set_devicedirectory(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  devicedirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.devicedirectory)
}
inline void xclLoadBitstream_call::set_devicedirectory(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  devicedirectory_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclLoadBitstream_call.devicedirectory)
}
inline void xclLoadBitstream_call::set_devicedirectory(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  devicedirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclLoadBitstream_call.devicedirectory)
}
inline void xclLoadBitstream_call::set_devicedirectory(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000008u;
  devicedirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclLoadBitstream_call.devicedirectory)
}
inline std::string* xclLoadBitstream_call::mutable_devicedirectory() {
  _has_bits_[0] |= 0x00000008u;
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.devicedirectory)
  return devicedirectory_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclLoadBitstream_call::release_devicedirectory() {
  // @@protoc_insertion_point(field_release:xclLoadBitstream_call.devicedirectory)
  if (!has_devicedirectory()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return devicedirectory_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclLoadBitstream_call::set_allocated_devicedirectory(std::string* devicedirectory) {
  if (devicedirectory != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  devicedirectory_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), devicedirectory);
  // @@protoc_insertion_point(field_set_allocated:xclLoadBitstream_call.devicedirectory)
}

// required bytes binarydirectory = 5;
inline bool xclLoadBitstream_call::has_binarydirectory() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclLoadBitstream_call::clear_binarydirectory() {
  binarydirectory_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& xclLoadBitstream_call::binarydirectory() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.binarydirectory)
  return binarydirectory_.GetNoArena();
}
inline void xclLoadBitstream_call::set_binarydirectory(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  binarydirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.binarydirectory)
}
inline void xclLoadBitstream_call::set_binarydirectory(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  binarydirectory_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclLoadBitstream_call.binarydirectory)
}
inline void xclLoadBitstream_call::set_binarydirectory(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  binarydirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclLoadBitstream_call.binarydirectory)
}
inline void xclLoadBitstream_call::set_binarydirectory(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000010u;
  binarydirectory_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclLoadBitstream_call.binarydirectory)
}
inline std::string* xclLoadBitstream_call::mutable_binarydirectory() {
  _has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.binarydirectory)
  return binarydirectory_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclLoadBitstream_call::release_binarydirectory() {
  // @@protoc_insertion_point(field_release:xclLoadBitstream_call.binarydirectory)
  if (!has_binarydirectory()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return binarydirectory_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclLoadBitstream_call::set_allocated_binarydirectory(std::string* binarydirectory) {
  if (binarydirectory != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  binarydirectory_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binarydirectory);
  // @@protoc_insertion_point(field_set_allocated:xclLoadBitstream_call.binarydirectory)
}

// required bool verbose = 6;
inline bool xclLoadBitstream_call::has_verbose() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclLoadBitstream_call::clear_verbose() {
  verbose_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool xclLoadBitstream_call::verbose() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.verbose)
  return verbose_;
}
inline void xclLoadBitstream_call::set_verbose(bool value) {
  _has_bits_[0] |= 0x00000020u;
  verbose_ = value;
  // @@protoc_insertion_point(field_set:xclLoadBitstream_call.verbose)
}

// repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
inline int xclLoadBitstream_call::ddrbanks_size() const {
  return ddrbanks_.size();
}
inline void xclLoadBitstream_call::clear_ddrbanks() {
  ddrbanks_.Clear();
}
inline ::xclLoadBitstream_call_ddrbank* xclLoadBitstream_call::mutable_ddrbanks(int index) {
  // @@protoc_insertion_point(field_mutable:xclLoadBitstream_call.ddrbanks)
  return ddrbanks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclLoadBitstream_call_ddrbank >*
xclLoadBitstream_call::mutable_ddrbanks() {
  // @@protoc_insertion_point(field_mutable_list:xclLoadBitstream_call.ddrbanks)
  return &ddrbanks_;
}
inline const ::xclLoadBitstream_call_ddrbank& xclLoadBitstream_call::ddrbanks(int index) const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_call.ddrbanks)
  return ddrbanks_.Get(index);
}
inline ::xclLoadBitstream_call_ddrbank* xclLoadBitstream_call::add_ddrbanks() {
  // @@protoc_insertion_point(field_add:xclLoadBitstream_call.ddrbanks)
  return ddrbanks_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclLoadBitstream_call_ddrbank >&
xclLoadBitstream_call::ddrbanks() const {
  // @@protoc_insertion_point(field_list:xclLoadBitstream_call.ddrbanks)
  return ddrbanks_;
}

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

// xclLoadBitstream_response

// required bool ack = 1;
inline bool xclLoadBitstream_response::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclLoadBitstream_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclLoadBitstream_response::ack() const {
  // @@protoc_insertion_point(field_get:xclLoadBitstream_response.ack)
  return ack_;
}
inline void xclLoadBitstream_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclLoadBitstream_response.ack)
}

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

// xclAllocDeviceBuffer_call

// required uint64 ddraddress = 1;
inline bool xclAllocDeviceBuffer_call::has_ddraddress() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclAllocDeviceBuffer_call::clear_ddraddress() {
  ddraddress_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclAllocDeviceBuffer_call::ddraddress() const {
  // @@protoc_insertion_point(field_get:xclAllocDeviceBuffer_call.ddraddress)
  return ddraddress_;
}
inline void xclAllocDeviceBuffer_call::set_ddraddress(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  ddraddress_ = value;
  // @@protoc_insertion_point(field_set:xclAllocDeviceBuffer_call.ddraddress)
}

// required uint64 size = 2;
inline bool xclAllocDeviceBuffer_call::has_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclAllocDeviceBuffer_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclAllocDeviceBuffer_call::size() const {
  // @@protoc_insertion_point(field_get:xclAllocDeviceBuffer_call.size)
  return size_;
}
inline void xclAllocDeviceBuffer_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclAllocDeviceBuffer_call.size)
}

// optional bool peertopeer = 3;
inline bool xclAllocDeviceBuffer_call::has_peertopeer() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclAllocDeviceBuffer_call::clear_peertopeer() {
  peertopeer_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool xclAllocDeviceBuffer_call::peertopeer() const {
  // @@protoc_insertion_point(field_get:xclAllocDeviceBuffer_call.peertopeer)
  return peertopeer_;
}
inline void xclAllocDeviceBuffer_call::set_peertopeer(bool value) {
  _has_bits_[0] |= 0x00000004u;
  peertopeer_ = value;
  // @@protoc_insertion_point(field_set:xclAllocDeviceBuffer_call.peertopeer)
}

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

// xclAllocDeviceBuffer_response

// required bool ack = 1;
inline bool xclAllocDeviceBuffer_response::has_ack() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclAllocDeviceBuffer_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclAllocDeviceBuffer_response::ack() const {
  // @@protoc_insertion_point(field_get:xclAllocDeviceBuffer_response.ack)
  return ack_;
}
inline void xclAllocDeviceBuffer_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000002u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclAllocDeviceBuffer_response.ack)
}

// optional string filename = 2;
inline bool xclAllocDeviceBuffer_response::has_filename() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclAllocDeviceBuffer_response::clear_filename() {
  filename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclAllocDeviceBuffer_response::filename() const {
  // @@protoc_insertion_point(field_get:xclAllocDeviceBuffer_response.filename)
  return filename_.GetNoArena();
}
inline void xclAllocDeviceBuffer_response::set_filename(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclAllocDeviceBuffer_response.filename)
}
inline void xclAllocDeviceBuffer_response::set_filename(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  filename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclAllocDeviceBuffer_response.filename)
}
inline void xclAllocDeviceBuffer_response::set_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclAllocDeviceBuffer_response.filename)
}
inline void xclAllocDeviceBuffer_response::set_filename(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclAllocDeviceBuffer_response.filename)
}
inline std::string* xclAllocDeviceBuffer_response::mutable_filename() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclAllocDeviceBuffer_response.filename)
  return filename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclAllocDeviceBuffer_response::release_filename() {
  // @@protoc_insertion_point(field_release:xclAllocDeviceBuffer_response.filename)
  if (!has_filename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return filename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclAllocDeviceBuffer_response::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  filename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), filename);
  // @@protoc_insertion_point(field_set_allocated:xclAllocDeviceBuffer_response.filename)
}

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

// xclFreeDeviceBuffer_call

// required uint64 ddraddress = 1;
inline bool xclFreeDeviceBuffer_call::has_ddraddress() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclFreeDeviceBuffer_call::clear_ddraddress() {
  ddraddress_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclFreeDeviceBuffer_call::ddraddress() const {
  // @@protoc_insertion_point(field_get:xclFreeDeviceBuffer_call.ddraddress)
  return ddraddress_;
}
inline void xclFreeDeviceBuffer_call::set_ddraddress(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  ddraddress_ = value;
  // @@protoc_insertion_point(field_set:xclFreeDeviceBuffer_call.ddraddress)
}

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

// xclFreeDeviceBuffer_response

// required bool ack = 1;
inline bool xclFreeDeviceBuffer_response::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclFreeDeviceBuffer_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclFreeDeviceBuffer_response::ack() const {
  // @@protoc_insertion_point(field_get:xclFreeDeviceBuffer_response.ack)
  return ack_;
}
inline void xclFreeDeviceBuffer_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclFreeDeviceBuffer_response.ack)
}

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

// xclClose_call

// optional bytes xclDeviceHandle = 2;
inline bool xclClose_call::has_xcldevicehandle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclClose_call::clear_xcldevicehandle() {
  xcldevicehandle_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclClose_call::xcldevicehandle() const {
  // @@protoc_insertion_point(field_get:xclClose_call.xclDeviceHandle)
  return xcldevicehandle_.GetNoArena();
}
inline void xclClose_call::set_xcldevicehandle(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclClose_call.xclDeviceHandle)
}
inline void xclClose_call::set_xcldevicehandle(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclClose_call.xclDeviceHandle)
}
inline void xclClose_call::set_xcldevicehandle(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclClose_call.xclDeviceHandle)
}
inline void xclClose_call::set_xcldevicehandle(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclClose_call.xclDeviceHandle)
}
inline std::string* xclClose_call::mutable_xcldevicehandle() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclClose_call.xclDeviceHandle)
  return xcldevicehandle_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclClose_call::release_xcldevicehandle() {
  // @@protoc_insertion_point(field_release:xclClose_call.xclDeviceHandle)
  if (!has_xcldevicehandle()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return xcldevicehandle_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclClose_call::set_allocated_xcldevicehandle(std::string* xcldevicehandle) {
  if (xcldevicehandle != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  xcldevicehandle_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), xcldevicehandle);
  // @@protoc_insertion_point(field_set_allocated:xclClose_call.xclDeviceHandle)
}

// optional bool closeall = 3;
inline bool xclClose_call::has_closeall() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclClose_call::clear_closeall() {
  closeall_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclClose_call::closeall() const {
  // @@protoc_insertion_point(field_get:xclClose_call.closeall)
  return closeall_;
}
inline void xclClose_call::set_closeall(bool value) {
  _has_bits_[0] |= 0x00000002u;
  closeall_ = value;
  // @@protoc_insertion_point(field_set:xclClose_call.closeall)
}

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

// xclClose_response

// required bool valid = 1;
inline bool xclClose_response::has_valid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclClose_response::clear_valid() {
  valid_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclClose_response::valid() const {
  // @@protoc_insertion_point(field_get:xclClose_response.valid)
  return valid_;
}
inline void xclClose_response::set_valid(bool value) {
  _has_bits_[0] |= 0x00000001u;
  valid_ = value;
  // @@protoc_insertion_point(field_set:xclClose_response.valid)
}

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

// xclCopyBufferHost2Device_call

// required bytes xclDeviceHandle = 2;
inline bool xclCopyBufferHost2Device_call::has_xcldevicehandle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_xcldevicehandle() {
  xcldevicehandle_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclCopyBufferHost2Device_call::xcldevicehandle() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.xclDeviceHandle)
  return xcldevicehandle_.GetNoArena();
}
inline void xclCopyBufferHost2Device_call::set_xcldevicehandle(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.xclDeviceHandle)
}
inline void xclCopyBufferHost2Device_call::set_xcldevicehandle(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBufferHost2Device_call.xclDeviceHandle)
}
inline void xclCopyBufferHost2Device_call::set_xcldevicehandle(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBufferHost2Device_call.xclDeviceHandle)
}
inline void xclCopyBufferHost2Device_call::set_xcldevicehandle(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBufferHost2Device_call.xclDeviceHandle)
}
inline std::string* xclCopyBufferHost2Device_call::mutable_xcldevicehandle() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclCopyBufferHost2Device_call.xclDeviceHandle)
  return xcldevicehandle_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBufferHost2Device_call::release_xcldevicehandle() {
  // @@protoc_insertion_point(field_release:xclCopyBufferHost2Device_call.xclDeviceHandle)
  if (!has_xcldevicehandle()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return xcldevicehandle_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBufferHost2Device_call::set_allocated_xcldevicehandle(std::string* xcldevicehandle) {
  if (xcldevicehandle != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  xcldevicehandle_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), xcldevicehandle);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBufferHost2Device_call.xclDeviceHandle)
}

// required uint64 dest = 3;
inline bool xclCopyBufferHost2Device_call::has_dest() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_dest() {
  dest_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferHost2Device_call::dest() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.dest)
  return dest_;
}
inline void xclCopyBufferHost2Device_call::set_dest(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  dest_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.dest)
}

// required bytes src = 4;
inline bool xclCopyBufferHost2Device_call::has_src() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_src() {
  src_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& xclCopyBufferHost2Device_call::src() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.src)
  return src_.GetNoArena();
}
inline void xclCopyBufferHost2Device_call::set_src(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.src)
}
inline void xclCopyBufferHost2Device_call::set_src(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  src_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBufferHost2Device_call.src)
}
inline void xclCopyBufferHost2Device_call::set_src(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBufferHost2Device_call.src)
}
inline void xclCopyBufferHost2Device_call::set_src(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBufferHost2Device_call.src)
}
inline std::string* xclCopyBufferHost2Device_call::mutable_src() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:xclCopyBufferHost2Device_call.src)
  return src_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBufferHost2Device_call::release_src() {
  // @@protoc_insertion_point(field_release:xclCopyBufferHost2Device_call.src)
  if (!has_src()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return src_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBufferHost2Device_call::set_allocated_src(std::string* src) {
  if (src != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  src_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), src);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBufferHost2Device_call.src)
}

// required uint64 size = 5;
inline bool xclCopyBufferHost2Device_call::has_size() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferHost2Device_call::size() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.size)
  return size_;
}
inline void xclCopyBufferHost2Device_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.size)
}

// required uint64 seek = 6;
inline bool xclCopyBufferHost2Device_call::has_seek() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_seek() {
  seek_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferHost2Device_call::seek() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.seek)
  return seek_;
}
inline void xclCopyBufferHost2Device_call::set_seek(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  seek_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.seek)
}

// optional uint32 space = 7;
inline bool xclCopyBufferHost2Device_call::has_space() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclCopyBufferHost2Device_call::clear_space() {
  space_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCopyBufferHost2Device_call::space() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_call.space)
  return space_;
}
inline void xclCopyBufferHost2Device_call::set_space(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  space_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_call.space)
}

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

// xclCopyBufferHost2Device_response

// required uint64 size = 1;
inline bool xclCopyBufferHost2Device_response::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBufferHost2Device_response::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferHost2Device_response::size() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferHost2Device_response.size)
  return size_;
}
inline void xclCopyBufferHost2Device_response::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferHost2Device_response.size)
}

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

// xclCopyBufferDevice2Host_call

// required bytes xclDeviceHandle = 2;
inline bool xclCopyBufferDevice2Host_call::has_xcldevicehandle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_xcldevicehandle() {
  xcldevicehandle_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclCopyBufferDevice2Host_call::xcldevicehandle() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.xclDeviceHandle)
  return xcldevicehandle_.GetNoArena();
}
inline void xclCopyBufferDevice2Host_call::set_xcldevicehandle(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.xclDeviceHandle)
}
inline void xclCopyBufferDevice2Host_call::set_xcldevicehandle(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBufferDevice2Host_call.xclDeviceHandle)
}
inline void xclCopyBufferDevice2Host_call::set_xcldevicehandle(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBufferDevice2Host_call.xclDeviceHandle)
}
inline void xclCopyBufferDevice2Host_call::set_xcldevicehandle(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  xcldevicehandle_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBufferDevice2Host_call.xclDeviceHandle)
}
inline std::string* xclCopyBufferDevice2Host_call::mutable_xcldevicehandle() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclCopyBufferDevice2Host_call.xclDeviceHandle)
  return xcldevicehandle_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBufferDevice2Host_call::release_xcldevicehandle() {
  // @@protoc_insertion_point(field_release:xclCopyBufferDevice2Host_call.xclDeviceHandle)
  if (!has_xcldevicehandle()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return xcldevicehandle_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBufferDevice2Host_call::set_allocated_xcldevicehandle(std::string* xcldevicehandle) {
  if (xcldevicehandle != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  xcldevicehandle_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), xcldevicehandle);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBufferDevice2Host_call.xclDeviceHandle)
}

// required bytes dest = 3;
inline bool xclCopyBufferDevice2Host_call::has_dest() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_dest() {
  dest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& xclCopyBufferDevice2Host_call::dest() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.dest)
  return dest_.GetNoArena();
}
inline void xclCopyBufferDevice2Host_call::set_dest(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.dest)
}
inline void xclCopyBufferDevice2Host_call::set_dest(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  dest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBufferDevice2Host_call.dest)
}
inline void xclCopyBufferDevice2Host_call::set_dest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBufferDevice2Host_call.dest)
}
inline void xclCopyBufferDevice2Host_call::set_dest(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBufferDevice2Host_call.dest)
}
inline std::string* xclCopyBufferDevice2Host_call::mutable_dest() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:xclCopyBufferDevice2Host_call.dest)
  return dest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBufferDevice2Host_call::release_dest() {
  // @@protoc_insertion_point(field_release:xclCopyBufferDevice2Host_call.dest)
  if (!has_dest()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return dest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBufferDevice2Host_call::set_allocated_dest(std::string* dest) {
  if (dest != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  dest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dest);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBufferDevice2Host_call.dest)
}

// required uint64 src = 4;
inline bool xclCopyBufferDevice2Host_call::has_src() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_src() {
  src_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferDevice2Host_call::src() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.src)
  return src_;
}
inline void xclCopyBufferDevice2Host_call::set_src(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  src_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.src)
}

// required uint64 size = 5;
inline bool xclCopyBufferDevice2Host_call::has_size() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferDevice2Host_call::size() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.size)
  return size_;
}
inline void xclCopyBufferDevice2Host_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.size)
}

// required uint64 skip = 6;
inline bool xclCopyBufferDevice2Host_call::has_skip() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_skip() {
  skip_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferDevice2Host_call::skip() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.skip)
  return skip_;
}
inline void xclCopyBufferDevice2Host_call::set_skip(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  skip_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.skip)
}

// optional uint32 space = 7;
inline bool xclCopyBufferDevice2Host_call::has_space() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclCopyBufferDevice2Host_call::clear_space() {
  space_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCopyBufferDevice2Host_call::space() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_call.space)
  return space_;
}
inline void xclCopyBufferDevice2Host_call::set_space(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  space_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_call.space)
}

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

// xclCopyBufferDevice2Host_response

// required uint64 size = 1;
inline bool xclCopyBufferDevice2Host_response::has_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclCopyBufferDevice2Host_response::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBufferDevice2Host_response::size() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_response.size)
  return size_;
}
inline void xclCopyBufferDevice2Host_response::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_response.size)
}

// required bytes dest = 2;
inline bool xclCopyBufferDevice2Host_response::has_dest() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBufferDevice2Host_response::clear_dest() {
  dest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclCopyBufferDevice2Host_response::dest() const {
  // @@protoc_insertion_point(field_get:xclCopyBufferDevice2Host_response.dest)
  return dest_.GetNoArena();
}
inline void xclCopyBufferDevice2Host_response::set_dest(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBufferDevice2Host_response.dest)
}
inline void xclCopyBufferDevice2Host_response::set_dest(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBufferDevice2Host_response.dest)
}
inline void xclCopyBufferDevice2Host_response::set_dest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBufferDevice2Host_response.dest)
}
inline void xclCopyBufferDevice2Host_response::set_dest(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBufferDevice2Host_response.dest)
}
inline std::string* xclCopyBufferDevice2Host_response::mutable_dest() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclCopyBufferDevice2Host_response.dest)
  return dest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBufferDevice2Host_response::release_dest() {
  // @@protoc_insertion_point(field_release:xclCopyBufferDevice2Host_response.dest)
  if (!has_dest()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBufferDevice2Host_response::set_allocated_dest(std::string* dest) {
  if (dest != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dest);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBufferDevice2Host_response.dest)
}

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

// xclWriteAddrSpaceDeviceRam_call

// required uint64 addr = 2;
inline bool xclWriteAddrSpaceDeviceRam_call::has_addr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclWriteAddrSpaceDeviceRam_call::clear_addr() {
  addr_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteAddrSpaceDeviceRam_call::addr() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrSpaceDeviceRam_call.addr)
  return addr_;
}
inline void xclWriteAddrSpaceDeviceRam_call::set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  addr_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrSpaceDeviceRam_call.addr)
}

// required uint32 size = 3;
inline bool xclWriteAddrSpaceDeviceRam_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclWriteAddrSpaceDeviceRam_call::clear_size() {
  size_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclWriteAddrSpaceDeviceRam_call::size() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrSpaceDeviceRam_call.size)
  return size_;
}
inline void xclWriteAddrSpaceDeviceRam_call::set_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrSpaceDeviceRam_call.size)
}

// required bytes data = 4;
inline bool xclWriteAddrSpaceDeviceRam_call::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteAddrSpaceDeviceRam_call::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclWriteAddrSpaceDeviceRam_call::data() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrSpaceDeviceRam_call.data)
  return data_.GetNoArena();
}
inline void xclWriteAddrSpaceDeviceRam_call::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclWriteAddrSpaceDeviceRam_call.data)
}
inline void xclWriteAddrSpaceDeviceRam_call::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclWriteAddrSpaceDeviceRam_call.data)
}
inline void xclWriteAddrSpaceDeviceRam_call::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclWriteAddrSpaceDeviceRam_call.data)
}
inline void xclWriteAddrSpaceDeviceRam_call::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclWriteAddrSpaceDeviceRam_call.data)
}
inline std::string* xclWriteAddrSpaceDeviceRam_call::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclWriteAddrSpaceDeviceRam_call.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclWriteAddrSpaceDeviceRam_call::release_data() {
  // @@protoc_insertion_point(field_release:xclWriteAddrSpaceDeviceRam_call.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclWriteAddrSpaceDeviceRam_call::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclWriteAddrSpaceDeviceRam_call.data)
}

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

// xclWriteAddrSpaceDeviceRam_response

// required bool valid = 1;
inline bool xclWriteAddrSpaceDeviceRam_response::has_valid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteAddrSpaceDeviceRam_response::clear_valid() {
  valid_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclWriteAddrSpaceDeviceRam_response::valid() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrSpaceDeviceRam_response.valid)
  return valid_;
}
inline void xclWriteAddrSpaceDeviceRam_response::set_valid(bool value) {
  _has_bits_[0] |= 0x00000001u;
  valid_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrSpaceDeviceRam_response.valid)
}

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

// xclWriteAddrKernelCtrl_call_kernelInfo

// optional uint64 addr = 1;
inline bool xclWriteAddrKernelCtrl_call_kernelInfo::has_addr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::clear_addr() {
  addr_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteAddrKernelCtrl_call_kernelInfo::addr() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.kernelInfo.addr)
  return addr_;
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  addr_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.kernelInfo.addr)
}

// optional uint32 size = 2;
inline bool xclWriteAddrKernelCtrl_call_kernelInfo::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::clear_size() {
  size_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclWriteAddrKernelCtrl_call_kernelInfo::size() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.kernelInfo.size)
  return size_;
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.kernelInfo.size)
}

// optional string name = 3;
inline bool xclWriteAddrKernelCtrl_call_kernelInfo::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclWriteAddrKernelCtrl_call_kernelInfo::name() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.kernelInfo.name)
  return name_.GetNoArena();
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.kernelInfo.name)
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclWriteAddrKernelCtrl_call.kernelInfo.name)
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclWriteAddrKernelCtrl_call.kernelInfo.name)
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclWriteAddrKernelCtrl_call.kernelInfo.name)
}
inline std::string* xclWriteAddrKernelCtrl_call_kernelInfo::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclWriteAddrKernelCtrl_call.kernelInfo.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclWriteAddrKernelCtrl_call_kernelInfo::release_name() {
  // @@protoc_insertion_point(field_release:xclWriteAddrKernelCtrl_call.kernelInfo.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclWriteAddrKernelCtrl_call_kernelInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:xclWriteAddrKernelCtrl_call.kernelInfo.name)
}

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

// xclWriteAddrKernelCtrl_call

// required uint64 addr = 2;
inline bool xclWriteAddrKernelCtrl_call::has_addr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclWriteAddrKernelCtrl_call::clear_addr() {
  addr_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteAddrKernelCtrl_call::addr() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.addr)
  return addr_;
}
inline void xclWriteAddrKernelCtrl_call::set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  addr_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.addr)
}

// required uint32 size = 3;
inline bool xclWriteAddrKernelCtrl_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclWriteAddrKernelCtrl_call::clear_size() {
  size_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclWriteAddrKernelCtrl_call::size() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.size)
  return size_;
}
inline void xclWriteAddrKernelCtrl_call::set_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.size)
}

// required bytes data = 4;
inline bool xclWriteAddrKernelCtrl_call::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteAddrKernelCtrl_call::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclWriteAddrKernelCtrl_call::data() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.data)
  return data_.GetNoArena();
}
inline void xclWriteAddrKernelCtrl_call::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_call.data)
}
inline void xclWriteAddrKernelCtrl_call::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclWriteAddrKernelCtrl_call.data)
}
inline void xclWriteAddrKernelCtrl_call::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclWriteAddrKernelCtrl_call.data)
}
inline void xclWriteAddrKernelCtrl_call::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclWriteAddrKernelCtrl_call.data)
}
inline std::string* xclWriteAddrKernelCtrl_call::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclWriteAddrKernelCtrl_call.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclWriteAddrKernelCtrl_call::release_data() {
  // @@protoc_insertion_point(field_release:xclWriteAddrKernelCtrl_call.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclWriteAddrKernelCtrl_call::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclWriteAddrKernelCtrl_call.data)
}

// repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
inline int xclWriteAddrKernelCtrl_call::kernel_info_size() const {
  return kernel_info_.size();
}
inline void xclWriteAddrKernelCtrl_call::clear_kernel_info() {
  kernel_info_.Clear();
}
inline ::xclWriteAddrKernelCtrl_call_kernelInfo* xclWriteAddrKernelCtrl_call::mutable_kernel_info(int index) {
  // @@protoc_insertion_point(field_mutable:xclWriteAddrKernelCtrl_call.kernel_info)
  return kernel_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclWriteAddrKernelCtrl_call_kernelInfo >*
xclWriteAddrKernelCtrl_call::mutable_kernel_info() {
  // @@protoc_insertion_point(field_mutable_list:xclWriteAddrKernelCtrl_call.kernel_info)
  return &kernel_info_;
}
inline const ::xclWriteAddrKernelCtrl_call_kernelInfo& xclWriteAddrKernelCtrl_call::kernel_info(int index) const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_call.kernel_info)
  return kernel_info_.Get(index);
}
inline ::xclWriteAddrKernelCtrl_call_kernelInfo* xclWriteAddrKernelCtrl_call::add_kernel_info() {
  // @@protoc_insertion_point(field_add:xclWriteAddrKernelCtrl_call.kernel_info)
  return kernel_info_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclWriteAddrKernelCtrl_call_kernelInfo >&
xclWriteAddrKernelCtrl_call::kernel_info() const {
  // @@protoc_insertion_point(field_list:xclWriteAddrKernelCtrl_call.kernel_info)
  return kernel_info_;
}

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

// xclWriteAddrKernelCtrl_response

// required bool valid = 1;
inline bool xclWriteAddrKernelCtrl_response::has_valid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteAddrKernelCtrl_response::clear_valid() {
  valid_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclWriteAddrKernelCtrl_response::valid() const {
  // @@protoc_insertion_point(field_get:xclWriteAddrKernelCtrl_response.valid)
  return valid_;
}
inline void xclWriteAddrKernelCtrl_response::set_valid(bool value) {
  _has_bits_[0] |= 0x00000001u;
  valid_ = value;
  // @@protoc_insertion_point(field_set:xclWriteAddrKernelCtrl_response.valid)
}

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

// xclReadAddrSpaceDeviceRam_call

// required uint64 addr = 2;
inline bool xclReadAddrSpaceDeviceRam_call::has_addr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadAddrSpaceDeviceRam_call::clear_addr() {
  addr_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadAddrSpaceDeviceRam_call::addr() const {
  // @@protoc_insertion_point(field_get:xclReadAddrSpaceDeviceRam_call.addr)
  return addr_;
}
inline void xclReadAddrSpaceDeviceRam_call::set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  addr_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrSpaceDeviceRam_call.addr)
}

// required uint32 size = 3;
inline bool xclReadAddrSpaceDeviceRam_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclReadAddrSpaceDeviceRam_call::clear_size() {
  size_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclReadAddrSpaceDeviceRam_call::size() const {
  // @@protoc_insertion_point(field_get:xclReadAddrSpaceDeviceRam_call.size)
  return size_;
}
inline void xclReadAddrSpaceDeviceRam_call::set_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrSpaceDeviceRam_call.size)
}

// optional bytes data = 4;
inline bool xclReadAddrSpaceDeviceRam_call::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadAddrSpaceDeviceRam_call::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadAddrSpaceDeviceRam_call::data() const {
  // @@protoc_insertion_point(field_get:xclReadAddrSpaceDeviceRam_call.data)
  return data_.GetNoArena();
}
inline void xclReadAddrSpaceDeviceRam_call::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadAddrSpaceDeviceRam_call.data)
}
inline void xclReadAddrSpaceDeviceRam_call::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadAddrSpaceDeviceRam_call.data)
}
inline void xclReadAddrSpaceDeviceRam_call::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadAddrSpaceDeviceRam_call.data)
}
inline void xclReadAddrSpaceDeviceRam_call::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadAddrSpaceDeviceRam_call.data)
}
inline std::string* xclReadAddrSpaceDeviceRam_call::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadAddrSpaceDeviceRam_call.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadAddrSpaceDeviceRam_call::release_data() {
  // @@protoc_insertion_point(field_release:xclReadAddrSpaceDeviceRam_call.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadAddrSpaceDeviceRam_call::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclReadAddrSpaceDeviceRam_call.data)
}

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

// xclReadAddrSpaceDeviceRam_response

// required bool valid = 1;
inline bool xclReadAddrSpaceDeviceRam_response::has_valid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadAddrSpaceDeviceRam_response::clear_valid() {
  valid_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclReadAddrSpaceDeviceRam_response::valid() const {
  // @@protoc_insertion_point(field_get:xclReadAddrSpaceDeviceRam_response.valid)
  return valid_;
}
inline void xclReadAddrSpaceDeviceRam_response::set_valid(bool value) {
  _has_bits_[0] |= 0x00000002u;
  valid_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrSpaceDeviceRam_response.valid)
}

// optional bytes data = 2;
inline bool xclReadAddrSpaceDeviceRam_response::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadAddrSpaceDeviceRam_response::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadAddrSpaceDeviceRam_response::data() const {
  // @@protoc_insertion_point(field_get:xclReadAddrSpaceDeviceRam_response.data)
  return data_.GetNoArena();
}
inline void xclReadAddrSpaceDeviceRam_response::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadAddrSpaceDeviceRam_response.data)
}
inline void xclReadAddrSpaceDeviceRam_response::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadAddrSpaceDeviceRam_response.data)
}
inline void xclReadAddrSpaceDeviceRam_response::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadAddrSpaceDeviceRam_response.data)
}
inline void xclReadAddrSpaceDeviceRam_response::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadAddrSpaceDeviceRam_response.data)
}
inline std::string* xclReadAddrSpaceDeviceRam_response::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadAddrSpaceDeviceRam_response.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadAddrSpaceDeviceRam_response::release_data() {
  // @@protoc_insertion_point(field_release:xclReadAddrSpaceDeviceRam_response.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadAddrSpaceDeviceRam_response::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclReadAddrSpaceDeviceRam_response.data)
}

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

// xclReadAddrKernelCtrl_call

// required uint64 addr = 2;
inline bool xclReadAddrKernelCtrl_call::has_addr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadAddrKernelCtrl_call::clear_addr() {
  addr_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadAddrKernelCtrl_call::addr() const {
  // @@protoc_insertion_point(field_get:xclReadAddrKernelCtrl_call.addr)
  return addr_;
}
inline void xclReadAddrKernelCtrl_call::set_addr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  addr_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrKernelCtrl_call.addr)
}

// required uint32 size = 3;
inline bool xclReadAddrKernelCtrl_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclReadAddrKernelCtrl_call::clear_size() {
  size_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclReadAddrKernelCtrl_call::size() const {
  // @@protoc_insertion_point(field_get:xclReadAddrKernelCtrl_call.size)
  return size_;
}
inline void xclReadAddrKernelCtrl_call::set_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrKernelCtrl_call.size)
}

// optional bytes data = 4;
inline bool xclReadAddrKernelCtrl_call::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadAddrKernelCtrl_call::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadAddrKernelCtrl_call::data() const {
  // @@protoc_insertion_point(field_get:xclReadAddrKernelCtrl_call.data)
  return data_.GetNoArena();
}
inline void xclReadAddrKernelCtrl_call::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadAddrKernelCtrl_call.data)
}
inline void xclReadAddrKernelCtrl_call::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadAddrKernelCtrl_call.data)
}
inline void xclReadAddrKernelCtrl_call::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadAddrKernelCtrl_call.data)
}
inline void xclReadAddrKernelCtrl_call::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadAddrKernelCtrl_call.data)
}
inline std::string* xclReadAddrKernelCtrl_call::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadAddrKernelCtrl_call.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadAddrKernelCtrl_call::release_data() {
  // @@protoc_insertion_point(field_release:xclReadAddrKernelCtrl_call.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadAddrKernelCtrl_call::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclReadAddrKernelCtrl_call.data)
}

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

// xclReadAddrKernelCtrl_response

// required bool valid = 1;
inline bool xclReadAddrKernelCtrl_response::has_valid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadAddrKernelCtrl_response::clear_valid() {
  valid_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclReadAddrKernelCtrl_response::valid() const {
  // @@protoc_insertion_point(field_get:xclReadAddrKernelCtrl_response.valid)
  return valid_;
}
inline void xclReadAddrKernelCtrl_response::set_valid(bool value) {
  _has_bits_[0] |= 0x00000002u;
  valid_ = value;
  // @@protoc_insertion_point(field_set:xclReadAddrKernelCtrl_response.valid)
}

// optional bytes data = 2;
inline bool xclReadAddrKernelCtrl_response::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadAddrKernelCtrl_response::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadAddrKernelCtrl_response::data() const {
  // @@protoc_insertion_point(field_get:xclReadAddrKernelCtrl_response.data)
  return data_.GetNoArena();
}
inline void xclReadAddrKernelCtrl_response::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadAddrKernelCtrl_response.data)
}
inline void xclReadAddrKernelCtrl_response::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadAddrKernelCtrl_response.data)
}
inline void xclReadAddrKernelCtrl_response::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadAddrKernelCtrl_response.data)
}
inline void xclReadAddrKernelCtrl_response::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadAddrKernelCtrl_response.data)
}
inline std::string* xclReadAddrKernelCtrl_response::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadAddrKernelCtrl_response.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadAddrKernelCtrl_response::release_data() {
  // @@protoc_insertion_point(field_release:xclReadAddrKernelCtrl_response.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadAddrKernelCtrl_response::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:xclReadAddrKernelCtrl_response.data)
}

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

// xclPerfMonReadCounters_call

// required string slotname = 1;
inline bool xclPerfMonReadCounters_call::has_slotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadCounters_call::clear_slotname() {
  slotname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPerfMonReadCounters_call::slotname() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_call.slotname)
  return slotname_.GetNoArena();
}
inline void xclPerfMonReadCounters_call::set_slotname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_call.slotname)
}
inline void xclPerfMonReadCounters_call::set_slotname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPerfMonReadCounters_call.slotname)
}
inline void xclPerfMonReadCounters_call::set_slotname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPerfMonReadCounters_call.slotname)
}
inline void xclPerfMonReadCounters_call::set_slotname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPerfMonReadCounters_call.slotname)
}
inline std::string* xclPerfMonReadCounters_call::mutable_slotname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadCounters_call.slotname)
  return slotname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPerfMonReadCounters_call::release_slotname() {
  // @@protoc_insertion_point(field_release:xclPerfMonReadCounters_call.slotname)
  if (!has_slotname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return slotname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPerfMonReadCounters_call::set_allocated_slotname(std::string* slotname) {
  if (slotname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  slotname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), slotname);
  // @@protoc_insertion_point(field_set_allocated:xclPerfMonReadCounters_call.slotname)
}

// optional bool accel = 2;
inline bool xclPerfMonReadCounters_call::has_accel() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadCounters_call::clear_accel() {
  accel_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclPerfMonReadCounters_call::accel() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_call.accel)
  return accel_;
}
inline void xclPerfMonReadCounters_call::set_accel(bool value) {
  _has_bits_[0] |= 0x00000002u;
  accel_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_call.accel)
}

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

// xclPerfMonReadCounters_response

// optional uint32 wr_byte_count = 1;
inline bool xclPerfMonReadCounters_response::has_wr_byte_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_wr_byte_count() {
  wr_byte_count_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::wr_byte_count() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.wr_byte_count)
  return wr_byte_count_;
}
inline void xclPerfMonReadCounters_response::set_wr_byte_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  wr_byte_count_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.wr_byte_count)
}

// optional uint32 wr_trans_count = 2;
inline bool xclPerfMonReadCounters_response::has_wr_trans_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_wr_trans_count() {
  wr_trans_count_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::wr_trans_count() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.wr_trans_count)
  return wr_trans_count_;
}
inline void xclPerfMonReadCounters_response::set_wr_trans_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  wr_trans_count_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.wr_trans_count)
}

// optional uint32 total_wr_latency = 3;
inline bool xclPerfMonReadCounters_response::has_total_wr_latency() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_total_wr_latency() {
  total_wr_latency_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::total_wr_latency() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.total_wr_latency)
  return total_wr_latency_;
}
inline void xclPerfMonReadCounters_response::set_total_wr_latency(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  total_wr_latency_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.total_wr_latency)
}

// optional uint32 rd_byte_count = 4;
inline bool xclPerfMonReadCounters_response::has_rd_byte_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_rd_byte_count() {
  rd_byte_count_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::rd_byte_count() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.rd_byte_count)
  return rd_byte_count_;
}
inline void xclPerfMonReadCounters_response::set_rd_byte_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  rd_byte_count_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.rd_byte_count)
}

// optional uint32 rd_trans_count = 5;
inline bool xclPerfMonReadCounters_response::has_rd_trans_count() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_rd_trans_count() {
  rd_trans_count_ = 0u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::rd_trans_count() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.rd_trans_count)
  return rd_trans_count_;
}
inline void xclPerfMonReadCounters_response::set_rd_trans_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  rd_trans_count_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.rd_trans_count)
}

// optional uint32 total_rd_latency = 6;
inline bool xclPerfMonReadCounters_response::has_total_rd_latency() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclPerfMonReadCounters_response::clear_total_rd_latency() {
  total_rd_latency_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadCounters_response::total_rd_latency() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_response.total_rd_latency)
  return total_rd_latency_;
}
inline void xclPerfMonReadCounters_response::set_total_rd_latency(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  total_rd_latency_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_response.total_rd_latency)
}

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

// xclPerfMonGetTraceCount_call

// optional bool ack = 1;
inline bool xclPerfMonGetTraceCount_call::has_ack() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonGetTraceCount_call::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclPerfMonGetTraceCount_call::ack() const {
  // @@protoc_insertion_point(field_get:xclPerfMonGetTraceCount_call.ack)
  return ack_;
}
inline void xclPerfMonGetTraceCount_call::set_ack(bool value) {
  _has_bits_[0] |= 0x00000002u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonGetTraceCount_call.ack)
}

// optional string slotname = 2;
inline bool xclPerfMonGetTraceCount_call::has_slotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonGetTraceCount_call::clear_slotname() {
  slotname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPerfMonGetTraceCount_call::slotname() const {
  // @@protoc_insertion_point(field_get:xclPerfMonGetTraceCount_call.slotname)
  return slotname_.GetNoArena();
}
inline void xclPerfMonGetTraceCount_call::set_slotname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPerfMonGetTraceCount_call.slotname)
}
inline void xclPerfMonGetTraceCount_call::set_slotname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPerfMonGetTraceCount_call.slotname)
}
inline void xclPerfMonGetTraceCount_call::set_slotname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPerfMonGetTraceCount_call.slotname)
}
inline void xclPerfMonGetTraceCount_call::set_slotname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPerfMonGetTraceCount_call.slotname)
}
inline std::string* xclPerfMonGetTraceCount_call::mutable_slotname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPerfMonGetTraceCount_call.slotname)
  return slotname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPerfMonGetTraceCount_call::release_slotname() {
  // @@protoc_insertion_point(field_release:xclPerfMonGetTraceCount_call.slotname)
  if (!has_slotname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return slotname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPerfMonGetTraceCount_call::set_allocated_slotname(std::string* slotname) {
  if (slotname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  slotname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), slotname);
  // @@protoc_insertion_point(field_set_allocated:xclPerfMonGetTraceCount_call.slotname)
}

// optional bool accel = 3;
inline bool xclPerfMonGetTraceCount_call::has_accel() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonGetTraceCount_call::clear_accel() {
  accel_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool xclPerfMonGetTraceCount_call::accel() const {
  // @@protoc_insertion_point(field_get:xclPerfMonGetTraceCount_call.accel)
  return accel_;
}
inline void xclPerfMonGetTraceCount_call::set_accel(bool value) {
  _has_bits_[0] |= 0x00000004u;
  accel_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonGetTraceCount_call.accel)
}

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

// xclPerfMonGetTraceCount_response

// optional uint32 no_of_samples = 1;
inline bool xclPerfMonGetTraceCount_response::has_no_of_samples() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonGetTraceCount_response::clear_no_of_samples() {
  no_of_samples_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonGetTraceCount_response::no_of_samples() const {
  // @@protoc_insertion_point(field_get:xclPerfMonGetTraceCount_response.no_of_samples)
  return no_of_samples_;
}
inline void xclPerfMonGetTraceCount_response::set_no_of_samples(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  no_of_samples_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonGetTraceCount_response.no_of_samples)
}

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

// xclPerfMonReadTrace_call

// optional bool ack = 1;
inline bool xclPerfMonReadTrace_call::has_ack() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadTrace_call::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclPerfMonReadTrace_call::ack() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_call.ack)
  return ack_;
}
inline void xclPerfMonReadTrace_call::set_ack(bool value) {
  _has_bits_[0] |= 0x00000002u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_call.ack)
}

// optional string slotname = 2;
inline bool xclPerfMonReadTrace_call::has_slotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadTrace_call::clear_slotname() {
  slotname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPerfMonReadTrace_call::slotname() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_call.slotname)
  return slotname_.GetNoArena();
}
inline void xclPerfMonReadTrace_call::set_slotname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_call.slotname)
}
inline void xclPerfMonReadTrace_call::set_slotname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPerfMonReadTrace_call.slotname)
}
inline void xclPerfMonReadTrace_call::set_slotname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPerfMonReadTrace_call.slotname)
}
inline void xclPerfMonReadTrace_call::set_slotname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPerfMonReadTrace_call.slotname)
}
inline std::string* xclPerfMonReadTrace_call::mutable_slotname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadTrace_call.slotname)
  return slotname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPerfMonReadTrace_call::release_slotname() {
  // @@protoc_insertion_point(field_release:xclPerfMonReadTrace_call.slotname)
  if (!has_slotname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return slotname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPerfMonReadTrace_call::set_allocated_slotname(std::string* slotname) {
  if (slotname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  slotname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), slotname);
  // @@protoc_insertion_point(field_set_allocated:xclPerfMonReadTrace_call.slotname)
}

// optional bool accel = 3;
inline bool xclPerfMonReadTrace_call::has_accel() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonReadTrace_call::clear_accel() {
  accel_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool xclPerfMonReadTrace_call::accel() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_call.accel)
  return accel_;
}
inline void xclPerfMonReadTrace_call::set_accel(bool value) {
  _has_bits_[0] |= 0x00000004u;
  accel_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_call.accel)
}

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

// xclPerfMonReadTrace_response_events

// optional uint32 awlen = 1;
inline bool xclPerfMonReadTrace_response_events::has_awlen() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_awlen() {
  awlen_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::awlen() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.awlen)
  return awlen_;
}
inline void xclPerfMonReadTrace_response_events::set_awlen(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  awlen_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.awlen)
}

// optional uint32 arlen = 2;
inline bool xclPerfMonReadTrace_response_events::has_arlen() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_arlen() {
  arlen_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::arlen() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.arlen)
  return arlen_;
}
inline void xclPerfMonReadTrace_response_events::set_arlen(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  arlen_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.arlen)
}

// optional uint32 eventflags = 3;
inline bool xclPerfMonReadTrace_response_events::has_eventflags() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_eventflags() {
  eventflags_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::eventflags() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.eventflags)
  return eventflags_;
}
inline void xclPerfMonReadTrace_response_events::set_eventflags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  eventflags_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.eventflags)
}

// optional uint32 timestamp = 4;
inline bool xclPerfMonReadTrace_response_events::has_timestamp() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_timestamp() {
  timestamp_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::timestamp() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.timestamp)
  return timestamp_;
}
inline void xclPerfMonReadTrace_response_events::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.timestamp)
}

// optional uint64 host_timestamp = 5;
inline bool xclPerfMonReadTrace_response_events::has_host_timestamp() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_host_timestamp() {
  host_timestamp_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadTrace_response_events::host_timestamp() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.host_timestamp)
  return host_timestamp_;
}
inline void xclPerfMonReadTrace_response_events::set_host_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  host_timestamp_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.host_timestamp)
}

// optional uint32 rd_bytes = 6;
inline bool xclPerfMonReadTrace_response_events::has_rd_bytes() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_rd_bytes() {
  rd_bytes_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::rd_bytes() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.rd_bytes)
  return rd_bytes_;
}
inline void xclPerfMonReadTrace_response_events::set_rd_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  rd_bytes_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.rd_bytes)
}

// optional uint32 wr_bytes = 7;
inline bool xclPerfMonReadTrace_response_events::has_wr_bytes() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void xclPerfMonReadTrace_response_events::clear_wr_bytes() {
  wr_bytes_ = 0u;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_response_events::wr_bytes() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.events.wr_bytes)
  return wr_bytes_;
}
inline void xclPerfMonReadTrace_response_events::set_wr_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000040u;
  wr_bytes_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_response.events.wr_bytes)
}

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

// xclPerfMonReadTrace_response

// repeated .xclPerfMonReadTrace_response.events output_data = 8;
inline int xclPerfMonReadTrace_response::output_data_size() const {
  return output_data_.size();
}
inline void xclPerfMonReadTrace_response::clear_output_data() {
  output_data_.Clear();
}
inline ::xclPerfMonReadTrace_response_events* xclPerfMonReadTrace_response::mutable_output_data(int index) {
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadTrace_response.output_data)
  return output_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_response_events >*
xclPerfMonReadTrace_response::mutable_output_data() {
  // @@protoc_insertion_point(field_mutable_list:xclPerfMonReadTrace_response.output_data)
  return &output_data_;
}
inline const ::xclPerfMonReadTrace_response_events& xclPerfMonReadTrace_response::output_data(int index) const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_response.output_data)
  return output_data_.Get(index);
}
inline ::xclPerfMonReadTrace_response_events* xclPerfMonReadTrace_response::add_output_data() {
  // @@protoc_insertion_point(field_add:xclPerfMonReadTrace_response.output_data)
  return output_data_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_response_events >&
xclPerfMonReadTrace_response::output_data() const {
  // @@protoc_insertion_point(field_list:xclPerfMonReadTrace_response.output_data)
  return output_data_;
}

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

// ddr_mem_msg

// required bytes data = 1;
inline bool ddr_mem_msg::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ddr_mem_msg::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ddr_mem_msg::data() const {
  // @@protoc_insertion_point(field_get:ddr_mem_msg.data)
  return data_.GetNoArena();
}
inline void ddr_mem_msg::set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ddr_mem_msg.data)
}
inline void ddr_mem_msg::set_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ddr_mem_msg.data)
}
inline void ddr_mem_msg::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ddr_mem_msg.data)
}
inline void ddr_mem_msg::set_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ddr_mem_msg.data)
}
inline std::string* ddr_mem_msg::mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:ddr_mem_msg.data)
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ddr_mem_msg::release_data() {
  // @@protoc_insertion_point(field_release:ddr_mem_msg.data)
  if (!has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ddr_mem_msg::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:ddr_mem_msg.data)
}

// optional uint64 size = 2;
inline bool ddr_mem_msg::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ddr_mem_msg::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ddr_mem_msg::size() const {
  // @@protoc_insertion_point(field_get:ddr_mem_msg.size)
  return size_;
}
inline void ddr_mem_msg::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:ddr_mem_msg.size)
}

// optional bytes strb_data = 3;
inline bool ddr_mem_msg::has_strb_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ddr_mem_msg::clear_strb_data() {
  strb_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ddr_mem_msg::strb_data() const {
  // @@protoc_insertion_point(field_get:ddr_mem_msg.strb_data)
  return strb_data_.GetNoArena();
}
inline void ddr_mem_msg::set_strb_data(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  strb_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ddr_mem_msg.strb_data)
}
inline void ddr_mem_msg::set_strb_data(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  strb_data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ddr_mem_msg.strb_data)
}
inline void ddr_mem_msg::set_strb_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  strb_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ddr_mem_msg.strb_data)
}
inline void ddr_mem_msg::set_strb_data(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  strb_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ddr_mem_msg.strb_data)
}
inline std::string* ddr_mem_msg::mutable_strb_data() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:ddr_mem_msg.strb_data)
  return strb_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ddr_mem_msg::release_strb_data() {
  // @@protoc_insertion_point(field_release:ddr_mem_msg.strb_data)
  if (!has_strb_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return strb_data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ddr_mem_msg::set_allocated_strb_data(std::string* strb_data) {
  if (strb_data != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  strb_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), strb_data);
  // @@protoc_insertion_point(field_set_allocated:ddr_mem_msg.strb_data)
}

// optional uint64 fullsize = 4;
inline bool ddr_mem_msg::has_fullsize() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ddr_mem_msg::clear_fullsize() {
  fullsize_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ddr_mem_msg::fullsize() const {
  // @@protoc_insertion_point(field_get:ddr_mem_msg.fullsize)
  return fullsize_;
}
inline void ddr_mem_msg::set_fullsize(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  fullsize_ = value;
  // @@protoc_insertion_point(field_set:ddr_mem_msg.fullsize)
}

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

// xclGetDeviceTimestamp_call

// optional bool ack = 1;
inline bool xclGetDeviceTimestamp_call::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclGetDeviceTimestamp_call::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclGetDeviceTimestamp_call::ack() const {
  // @@protoc_insertion_point(field_get:xclGetDeviceTimestamp_call.ack)
  return ack_;
}
inline void xclGetDeviceTimestamp_call::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclGetDeviceTimestamp_call.ack)
}

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

// xclGetDeviceTimestamp_response

// required uint64 device_timestamp = 1;
inline bool xclGetDeviceTimestamp_response::has_device_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclGetDeviceTimestamp_response::clear_device_timestamp() {
  device_timestamp_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclGetDeviceTimestamp_response::device_timestamp() const {
  // @@protoc_insertion_point(field_get:xclGetDeviceTimestamp_response.device_timestamp)
  return device_timestamp_;
}
inline void xclGetDeviceTimestamp_response::set_device_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  device_timestamp_ = value;
  // @@protoc_insertion_point(field_set:xclGetDeviceTimestamp_response.device_timestamp)
}

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

// xclReadBusStatus_call

// optional int32 slot_n = 1;
inline bool xclReadBusStatus_call::has_slot_n() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadBusStatus_call::clear_slot_n() {
  slot_n_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 xclReadBusStatus_call::slot_n() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_call.slot_n)
  return slot_n_;
}
inline void xclReadBusStatus_call::set_slot_n(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  slot_n_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_call.slot_n)
}

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

// xclReadBusStatus_response

// optional uint64 uncomplete_rd_cycles = 1;
inline bool xclReadBusStatus_response::has_uncomplete_rd_cycles() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadBusStatus_response::clear_uncomplete_rd_cycles() {
  uncomplete_rd_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadBusStatus_response::uncomplete_rd_cycles() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_response.uncomplete_rd_cycles)
  return uncomplete_rd_cycles_;
}
inline void xclReadBusStatus_response::set_uncomplete_rd_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  uncomplete_rd_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_response.uncomplete_rd_cycles)
}

// optional uint64 uncomplete_wr_cycles = 2;
inline bool xclReadBusStatus_response::has_uncomplete_wr_cycles() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadBusStatus_response::clear_uncomplete_wr_cycles() {
  uncomplete_wr_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadBusStatus_response::uncomplete_wr_cycles() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_response.uncomplete_wr_cycles)
  return uncomplete_wr_cycles_;
}
inline void xclReadBusStatus_response::set_uncomplete_wr_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  uncomplete_wr_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_response.uncomplete_wr_cycles)
}

// optional uint64 idle_bus_cycles = 3;
inline bool xclReadBusStatus_response::has_idle_bus_cycles() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclReadBusStatus_response::clear_idle_bus_cycles() {
  idle_bus_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadBusStatus_response::idle_bus_cycles() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_response.idle_bus_cycles)
  return idle_bus_cycles_;
}
inline void xclReadBusStatus_response::set_idle_bus_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  idle_bus_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_response.idle_bus_cycles)
}

// optional uint64 uncomplete_rd_id = 4;
inline bool xclReadBusStatus_response::has_uncomplete_rd_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclReadBusStatus_response::clear_uncomplete_rd_id() {
  uncomplete_rd_id_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadBusStatus_response::uncomplete_rd_id() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_response.uncomplete_rd_id)
  return uncomplete_rd_id_;
}
inline void xclReadBusStatus_response::set_uncomplete_rd_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  uncomplete_rd_id_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_response.uncomplete_rd_id)
}

// optional uint64 uncomplete_wr_id = 5;
inline bool xclReadBusStatus_response::has_uncomplete_wr_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclReadBusStatus_response::clear_uncomplete_wr_id() {
  uncomplete_wr_id_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadBusStatus_response::uncomplete_wr_id() const {
  // @@protoc_insertion_point(field_get:xclReadBusStatus_response.uncomplete_wr_id)
  return uncomplete_wr_id_;
}
inline void xclReadBusStatus_response::set_uncomplete_wr_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  uncomplete_wr_id_ = value;
  // @@protoc_insertion_point(field_set:xclReadBusStatus_response.uncomplete_wr_id)
}

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

// xclGetDebugMessages_call

// optional bool ack = 1;
inline bool xclGetDebugMessages_call::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclGetDebugMessages_call::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclGetDebugMessages_call::ack() const {
  // @@protoc_insertion_point(field_get:xclGetDebugMessages_call.ack)
  return ack_;
}
inline void xclGetDebugMessages_call::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclGetDebugMessages_call.ack)
}

// optional bool force = 2;
inline bool xclGetDebugMessages_call::has_force() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclGetDebugMessages_call::clear_force() {
  force_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclGetDebugMessages_call::force() const {
  // @@protoc_insertion_point(field_get:xclGetDebugMessages_call.force)
  return force_;
}
inline void xclGetDebugMessages_call::set_force(bool value) {
  _has_bits_[0] |= 0x00000002u;
  force_ = value;
  // @@protoc_insertion_point(field_set:xclGetDebugMessages_call.force)
}

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

// xclGetDebugMessages_response

// optional bytes display_msgs = 1;
inline bool xclGetDebugMessages_response::has_display_msgs() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclGetDebugMessages_response::clear_display_msgs() {
  display_msgs_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclGetDebugMessages_response::display_msgs() const {
  // @@protoc_insertion_point(field_get:xclGetDebugMessages_response.display_msgs)
  return display_msgs_.GetNoArena();
}
inline void xclGetDebugMessages_response::set_display_msgs(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  display_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclGetDebugMessages_response.display_msgs)
}
inline void xclGetDebugMessages_response::set_display_msgs(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  display_msgs_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclGetDebugMessages_response.display_msgs)
}
inline void xclGetDebugMessages_response::set_display_msgs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  display_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclGetDebugMessages_response.display_msgs)
}
inline void xclGetDebugMessages_response::set_display_msgs(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  display_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclGetDebugMessages_response.display_msgs)
}
inline std::string* xclGetDebugMessages_response::mutable_display_msgs() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclGetDebugMessages_response.display_msgs)
  return display_msgs_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclGetDebugMessages_response::release_display_msgs() {
  // @@protoc_insertion_point(field_release:xclGetDebugMessages_response.display_msgs)
  if (!has_display_msgs()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return display_msgs_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclGetDebugMessages_response::set_allocated_display_msgs(std::string* display_msgs) {
  if (display_msgs != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  display_msgs_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), display_msgs);
  // @@protoc_insertion_point(field_set_allocated:xclGetDebugMessages_response.display_msgs)
}

// optional bytes log_msgs = 2;
inline bool xclGetDebugMessages_response::has_log_msgs() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclGetDebugMessages_response::clear_log_msgs() {
  log_msgs_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& xclGetDebugMessages_response::log_msgs() const {
  // @@protoc_insertion_point(field_get:xclGetDebugMessages_response.log_msgs)
  return log_msgs_.GetNoArena();
}
inline void xclGetDebugMessages_response::set_log_msgs(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  log_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclGetDebugMessages_response.log_msgs)
}
inline void xclGetDebugMessages_response::set_log_msgs(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  log_msgs_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclGetDebugMessages_response.log_msgs)
}
inline void xclGetDebugMessages_response::set_log_msgs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  log_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclGetDebugMessages_response.log_msgs)
}
inline void xclGetDebugMessages_response::set_log_msgs(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  log_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclGetDebugMessages_response.log_msgs)
}
inline std::string* xclGetDebugMessages_response::mutable_log_msgs() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:xclGetDebugMessages_response.log_msgs)
  return log_msgs_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclGetDebugMessages_response::release_log_msgs() {
  // @@protoc_insertion_point(field_release:xclGetDebugMessages_response.log_msgs)
  if (!has_log_msgs()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return log_msgs_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclGetDebugMessages_response::set_allocated_log_msgs(std::string* log_msgs) {
  if (log_msgs != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  log_msgs_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), log_msgs);
  // @@protoc_insertion_point(field_set_allocated:xclGetDebugMessages_response.log_msgs)
}

// optional bytes stop_msgs = 3;
inline bool xclGetDebugMessages_response::has_stop_msgs() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclGetDebugMessages_response::clear_stop_msgs() {
  stop_msgs_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& xclGetDebugMessages_response::stop_msgs() const {
  // @@protoc_insertion_point(field_get:xclGetDebugMessages_response.stop_msgs)
  return stop_msgs_.GetNoArena();
}
inline void xclGetDebugMessages_response::set_stop_msgs(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  stop_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclGetDebugMessages_response.stop_msgs)
}
inline void xclGetDebugMessages_response::set_stop_msgs(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  stop_msgs_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclGetDebugMessages_response.stop_msgs)
}
inline void xclGetDebugMessages_response::set_stop_msgs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  stop_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclGetDebugMessages_response.stop_msgs)
}
inline void xclGetDebugMessages_response::set_stop_msgs(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000004u;
  stop_msgs_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclGetDebugMessages_response.stop_msgs)
}
inline std::string* xclGetDebugMessages_response::mutable_stop_msgs() {
  _has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_mutable:xclGetDebugMessages_response.stop_msgs)
  return stop_msgs_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclGetDebugMessages_response::release_stop_msgs() {
  // @@protoc_insertion_point(field_release:xclGetDebugMessages_response.stop_msgs)
  if (!has_stop_msgs()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return stop_msgs_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclGetDebugMessages_response::set_allocated_stop_msgs(std::string* stop_msgs) {
  if (stop_msgs != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  stop_msgs_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stop_msgs);
  // @@protoc_insertion_point(field_set_allocated:xclGetDebugMessages_response.stop_msgs)
}

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

// xclImportBO_call

// optional string dst_filename = 1;
inline bool xclImportBO_call::has_dst_filename() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclImportBO_call::clear_dst_filename() {
  dst_filename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclImportBO_call::dst_filename() const {
  // @@protoc_insertion_point(field_get:xclImportBO_call.dst_filename)
  return dst_filename_.GetNoArena();
}
inline void xclImportBO_call::set_dst_filename(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclImportBO_call.dst_filename)
}
inline void xclImportBO_call::set_dst_filename(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclImportBO_call.dst_filename)
}
inline void xclImportBO_call::set_dst_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclImportBO_call.dst_filename)
}
inline void xclImportBO_call::set_dst_filename(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclImportBO_call.dst_filename)
}
inline std::string* xclImportBO_call::mutable_dst_filename() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclImportBO_call.dst_filename)
  return dst_filename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclImportBO_call::release_dst_filename() {
  // @@protoc_insertion_point(field_release:xclImportBO_call.dst_filename)
  if (!has_dst_filename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dst_filename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclImportBO_call::set_allocated_dst_filename(std::string* dst_filename) {
  if (dst_filename != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dst_filename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dst_filename);
  // @@protoc_insertion_point(field_set_allocated:xclImportBO_call.dst_filename)
}

// optional uint64 offset = 2;
inline bool xclImportBO_call::has_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclImportBO_call::clear_offset() {
  offset_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclImportBO_call::offset() const {
  // @@protoc_insertion_point(field_get:xclImportBO_call.offset)
  return offset_;
}
inline void xclImportBO_call::set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  offset_ = value;
  // @@protoc_insertion_point(field_set:xclImportBO_call.offset)
}

// optional uint64 size = 3;
inline bool xclImportBO_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclImportBO_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclImportBO_call::size() const {
  // @@protoc_insertion_point(field_get:xclImportBO_call.size)
  return size_;
}
inline void xclImportBO_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclImportBO_call.size)
}

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

// xclImportBO_response

// optional bool ack = 1;
inline bool xclImportBO_response::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclImportBO_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclImportBO_response::ack() const {
  // @@protoc_insertion_point(field_get:xclImportBO_response.ack)
  return ack_;
}
inline void xclImportBO_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclImportBO_response.ack)
}

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

// xclCopyBO_call

// optional uint64 src_handle = 1;
inline bool xclCopyBO_call::has_src_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclCopyBO_call::clear_src_handle() {
  src_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBO_call::src_handle() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_call.src_handle)
  return src_handle_;
}
inline void xclCopyBO_call::set_src_handle(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  src_handle_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBO_call.src_handle)
}

// optional string dst_filename = 2;
inline bool xclCopyBO_call::has_dst_filename() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBO_call::clear_dst_filename() {
  dst_filename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclCopyBO_call::dst_filename() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_call.dst_filename)
  return dst_filename_.GetNoArena();
}
inline void xclCopyBO_call::set_dst_filename(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclCopyBO_call.dst_filename)
}
inline void xclCopyBO_call::set_dst_filename(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclCopyBO_call.dst_filename)
}
inline void xclCopyBO_call::set_dst_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclCopyBO_call.dst_filename)
}
inline void xclCopyBO_call::set_dst_filename(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dst_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclCopyBO_call.dst_filename)
}
inline std::string* xclCopyBO_call::mutable_dst_filename() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclCopyBO_call.dst_filename)
  return dst_filename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclCopyBO_call::release_dst_filename() {
  // @@protoc_insertion_point(field_release:xclCopyBO_call.dst_filename)
  if (!has_dst_filename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dst_filename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclCopyBO_call::set_allocated_dst_filename(std::string* dst_filename) {
  if (dst_filename != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dst_filename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dst_filename);
  // @@protoc_insertion_point(field_set_allocated:xclCopyBO_call.dst_filename)
}

// optional uint64 size = 3;
inline bool xclCopyBO_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclCopyBO_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBO_call::size() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_call.size)
  return size_;
}
inline void xclCopyBO_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBO_call.size)
}

// optional uint64 src_offset = 4;
inline bool xclCopyBO_call::has_src_offset() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclCopyBO_call::clear_src_offset() {
  src_offset_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBO_call::src_offset() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_call.src_offset)
  return src_offset_;
}
inline void xclCopyBO_call::set_src_offset(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  src_offset_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBO_call.src_offset)
}

// optional uint64 dst_offset = 5;
inline bool xclCopyBO_call::has_dst_offset() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclCopyBO_call::clear_dst_offset() {
  dst_offset_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCopyBO_call::dst_offset() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_call.dst_offset)
  return dst_offset_;
}
inline void xclCopyBO_call::set_dst_offset(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  dst_offset_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBO_call.dst_offset)
}

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

// xclCopyBO_response

// optional bool ack = 1;
inline bool xclCopyBO_response::has_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCopyBO_response::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclCopyBO_response::ack() const {
  // @@protoc_insertion_point(field_get:xclCopyBO_response.ack)
  return ack_;
}
inline void xclCopyBO_response::set_ack(bool value) {
  _has_bits_[0] |= 0x00000001u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclCopyBO_response.ack)
}

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

// xclCreateQueue_call

// optional bool write = 1;
inline bool xclCreateQueue_call::has_write() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCreateQueue_call::clear_write() {
  write_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclCreateQueue_call::write() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.write)
  return write_;
}
inline void xclCreateQueue_call::set_write(bool value) {
  _has_bits_[0] |= 0x00000001u;
  write_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.write)
}

// optional uint32 type = 2;
inline bool xclCreateQueue_call::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclCreateQueue_call::clear_type() {
  type_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCreateQueue_call::type() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.type)
  return type_;
}
inline void xclCreateQueue_call::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  type_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.type)
}

// optional uint32 state = 3;
inline bool xclCreateQueue_call::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclCreateQueue_call::clear_state() {
  state_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCreateQueue_call::state() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.state)
  return state_;
}
inline void xclCreateQueue_call::set_state(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  state_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.state)
}

// optional uint32 route = 4;
inline bool xclCreateQueue_call::has_route() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclCreateQueue_call::clear_route() {
  route_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCreateQueue_call::route() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.route)
  return route_;
}
inline void xclCreateQueue_call::set_route(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  route_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.route)
}

// optional uint64 flow = 5;
inline bool xclCreateQueue_call::has_flow() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclCreateQueue_call::clear_flow() {
  flow_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCreateQueue_call::flow() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.flow)
  return flow_;
}
inline void xclCreateQueue_call::set_flow(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  flow_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.flow)
}

// optional uint32 qsize = 6;
inline bool xclCreateQueue_call::has_qsize() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclCreateQueue_call::clear_qsize() {
  qsize_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCreateQueue_call::qsize() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.qsize)
  return qsize_;
}
inline void xclCreateQueue_call::set_qsize(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  qsize_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.qsize)
}

// optional uint32 desc_size = 7;
inline bool xclCreateQueue_call::has_desc_size() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void xclCreateQueue_call::clear_desc_size() {
  desc_size_ = 0u;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclCreateQueue_call::desc_size() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.desc_size)
  return desc_size_;
}
inline void xclCreateQueue_call::set_desc_size(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000040u;
  desc_size_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.desc_size)
}

// optional uint64 flags = 8;
inline bool xclCreateQueue_call::has_flags() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void xclCreateQueue_call::clear_flags() {
  flags_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCreateQueue_call::flags() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_call.flags)
  return flags_;
}
inline void xclCreateQueue_call::set_flags(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000080u;
  flags_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_call.flags)
}

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

// xclCreateQueue_response

// optional uint64 q_handle = 1;
inline bool xclCreateQueue_response::has_q_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclCreateQueue_response::clear_q_handle() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclCreateQueue_response::q_handle() const {
  // @@protoc_insertion_point(field_get:xclCreateQueue_response.q_handle)
  return q_handle_;
}
inline void xclCreateQueue_response::set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  q_handle_ = value;
  // @@protoc_insertion_point(field_set:xclCreateQueue_response.q_handle)
}

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

// xclWriteQueue_call

// optional uint64 q_handle = 1;
inline bool xclWriteQueue_call::has_q_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclWriteQueue_call::clear_q_handle() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteQueue_call::q_handle() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.q_handle)
  return q_handle_;
}
inline void xclWriteQueue_call::set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  q_handle_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.q_handle)
}

// optional bytes src = 2;
inline bool xclWriteQueue_call::has_src() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteQueue_call::clear_src() {
  src_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclWriteQueue_call::src() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.src)
  return src_.GetNoArena();
}
inline void xclWriteQueue_call::set_src(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.src)
}
inline void xclWriteQueue_call::set_src(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  src_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclWriteQueue_call.src)
}
inline void xclWriteQueue_call::set_src(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclWriteQueue_call.src)
}
inline void xclWriteQueue_call::set_src(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  src_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclWriteQueue_call.src)
}
inline std::string* xclWriteQueue_call::mutable_src() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclWriteQueue_call.src)
  return src_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclWriteQueue_call::release_src() {
  // @@protoc_insertion_point(field_release:xclWriteQueue_call.src)
  if (!has_src()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return src_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclWriteQueue_call::set_allocated_src(std::string* src) {
  if (src != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  src_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), src);
  // @@protoc_insertion_point(field_set_allocated:xclWriteQueue_call.src)
}

// optional uint64 size = 3;
inline bool xclWriteQueue_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclWriteQueue_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteQueue_call::size() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.size)
  return size_;
}
inline void xclWriteQueue_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.size)
}

// optional uint64 req = 4;
inline bool xclWriteQueue_call::has_req() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclWriteQueue_call::clear_req() {
  req_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteQueue_call::req() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.req)
  return req_;
}
inline void xclWriteQueue_call::set_req(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  req_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.req)
}

// optional bool nonblocking = 5;
inline bool xclWriteQueue_call::has_nonblocking() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclWriteQueue_call::clear_nonblocking() {
  nonblocking_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool xclWriteQueue_call::nonblocking() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.nonblocking)
  return nonblocking_;
}
inline void xclWriteQueue_call::set_nonblocking(bool value) {
  _has_bits_[0] |= 0x00000010u;
  nonblocking_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.nonblocking)
}

// optional bool eot = 6;
inline bool xclWriteQueue_call::has_eot() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclWriteQueue_call::clear_eot() {
  eot_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool xclWriteQueue_call::eot() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_call.eot)
  return eot_;
}
inline void xclWriteQueue_call::set_eot(bool value) {
  _has_bits_[0] |= 0x00000020u;
  eot_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_call.eot)
}

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

// xclWriteQueue_response

// optional uint64 written_size = 1;
inline bool xclWriteQueue_response::has_written_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclWriteQueue_response::clear_written_size() {
  written_size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclWriteQueue_response::written_size() const {
  // @@protoc_insertion_point(field_get:xclWriteQueue_response.written_size)
  return written_size_;
}
inline void xclWriteQueue_response::set_written_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  written_size_ = value;
  // @@protoc_insertion_point(field_set:xclWriteQueue_response.written_size)
}

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

// xclReadQueue_call

// optional uint64 q_handle = 1;
inline bool xclReadQueue_call::has_q_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadQueue_call::clear_q_handle() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadQueue_call::q_handle() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.q_handle)
  return q_handle_;
}
inline void xclReadQueue_call::set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  q_handle_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_call.q_handle)
}

// optional bytes dest = 2;
inline bool xclReadQueue_call::has_dest() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadQueue_call::clear_dest() {
  dest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadQueue_call::dest() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.dest)
  return dest_.GetNoArena();
}
inline void xclReadQueue_call::set_dest(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadQueue_call.dest)
}
inline void xclReadQueue_call::set_dest(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadQueue_call.dest)
}
inline void xclReadQueue_call::set_dest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadQueue_call.dest)
}
inline void xclReadQueue_call::set_dest(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadQueue_call.dest)
}
inline std::string* xclReadQueue_call::mutable_dest() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadQueue_call.dest)
  return dest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadQueue_call::release_dest() {
  // @@protoc_insertion_point(field_release:xclReadQueue_call.dest)
  if (!has_dest()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadQueue_call::set_allocated_dest(std::string* dest) {
  if (dest != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dest);
  // @@protoc_insertion_point(field_set_allocated:xclReadQueue_call.dest)
}

// optional uint64 size = 3;
inline bool xclReadQueue_call::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclReadQueue_call::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadQueue_call::size() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.size)
  return size_;
}
inline void xclReadQueue_call::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_call.size)
}

// optional uint64 req = 4;
inline bool xclReadQueue_call::has_req() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclReadQueue_call::clear_req() {
  req_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadQueue_call::req() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.req)
  return req_;
}
inline void xclReadQueue_call::set_req(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  req_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_call.req)
}

// optional bool nonblocking = 5;
inline bool xclReadQueue_call::has_nonblocking() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclReadQueue_call::clear_nonblocking() {
  nonblocking_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool xclReadQueue_call::nonblocking() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.nonblocking)
  return nonblocking_;
}
inline void xclReadQueue_call::set_nonblocking(bool value) {
  _has_bits_[0] |= 0x00000010u;
  nonblocking_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_call.nonblocking)
}

// optional bool eot = 6;
inline bool xclReadQueue_call::has_eot() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void xclReadQueue_call::clear_eot() {
  eot_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool xclReadQueue_call::eot() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_call.eot)
  return eot_;
}
inline void xclReadQueue_call::set_eot(bool value) {
  _has_bits_[0] |= 0x00000020u;
  eot_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_call.eot)
}

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

// xclReadQueue_response

// optional bytes dest = 1;
inline bool xclReadQueue_response::has_dest() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclReadQueue_response::clear_dest() {
  dest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclReadQueue_response::dest() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_response.dest)
  return dest_.GetNoArena();
}
inline void xclReadQueue_response::set_dest(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclReadQueue_response.dest)
}
inline void xclReadQueue_response::set_dest(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclReadQueue_response.dest)
}
inline void xclReadQueue_response::set_dest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclReadQueue_response.dest)
}
inline void xclReadQueue_response::set_dest(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclReadQueue_response.dest)
}
inline std::string* xclReadQueue_response::mutable_dest() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclReadQueue_response.dest)
  return dest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclReadQueue_response::release_dest() {
  // @@protoc_insertion_point(field_release:xclReadQueue_response.dest)
  if (!has_dest()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclReadQueue_response::set_allocated_dest(std::string* dest) {
  if (dest != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dest);
  // @@protoc_insertion_point(field_set_allocated:xclReadQueue_response.dest)
}

// optional uint64 size = 2;
inline bool xclReadQueue_response::has_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclReadQueue_response::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclReadQueue_response::size() const {
  // @@protoc_insertion_point(field_get:xclReadQueue_response.size)
  return size_;
}
inline void xclReadQueue_response::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclReadQueue_response.size)
}

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

// xclPollCompletion_call

// optional uint64 req = 1;
inline bool xclPollCompletion_call::has_req() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPollCompletion_call::clear_req() {
  req_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPollCompletion_call::req() const {
  // @@protoc_insertion_point(field_get:xclPollCompletion_call.req)
  return req_;
}
inline void xclPollCompletion_call::set_req(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  req_ = value;
  // @@protoc_insertion_point(field_set:xclPollCompletion_call.req)
}

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

// xclPollCompletion_response_request

// optional bytes dest = 1;
inline bool xclPollCompletion_response_request::has_dest() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPollCompletion_response_request::clear_dest() {
  dest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPollCompletion_response_request::dest() const {
  // @@protoc_insertion_point(field_get:xclPollCompletion_response.request.dest)
  return dest_.GetNoArena();
}
inline void xclPollCompletion_response_request::set_dest(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPollCompletion_response.request.dest)
}
inline void xclPollCompletion_response_request::set_dest(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPollCompletion_response.request.dest)
}
inline void xclPollCompletion_response_request::set_dest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPollCompletion_response.request.dest)
}
inline void xclPollCompletion_response_request::set_dest(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  dest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPollCompletion_response.request.dest)
}
inline std::string* xclPollCompletion_response_request::mutable_dest() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPollCompletion_response.request.dest)
  return dest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPollCompletion_response_request::release_dest() {
  // @@protoc_insertion_point(field_release:xclPollCompletion_response.request.dest)
  if (!has_dest()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return dest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPollCompletion_response_request::set_allocated_dest(std::string* dest) {
  if (dest != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dest);
  // @@protoc_insertion_point(field_set_allocated:xclPollCompletion_response.request.dest)
}

// optional uint64 size = 2;
inline bool xclPollCompletion_response_request::has_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPollCompletion_response_request::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPollCompletion_response_request::size() const {
  // @@protoc_insertion_point(field_get:xclPollCompletion_response.request.size)
  return size_;
}
inline void xclPollCompletion_response_request::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  size_ = value;
  // @@protoc_insertion_point(field_set:xclPollCompletion_response.request.size)
}

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

// xclPollCompletion_response

// repeated .xclPollCompletion_response.request fullrequest = 3;
inline int xclPollCompletion_response::fullrequest_size() const {
  return fullrequest_.size();
}
inline void xclPollCompletion_response::clear_fullrequest() {
  fullrequest_.Clear();
}
inline ::xclPollCompletion_response_request* xclPollCompletion_response::mutable_fullrequest(int index) {
  // @@protoc_insertion_point(field_mutable:xclPollCompletion_response.fullrequest)
  return fullrequest_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPollCompletion_response_request >*
xclPollCompletion_response::mutable_fullrequest() {
  // @@protoc_insertion_point(field_mutable_list:xclPollCompletion_response.fullrequest)
  return &fullrequest_;
}
inline const ::xclPollCompletion_response_request& xclPollCompletion_response::fullrequest(int index) const {
  // @@protoc_insertion_point(field_get:xclPollCompletion_response.fullrequest)
  return fullrequest_.Get(index);
}
inline ::xclPollCompletion_response_request* xclPollCompletion_response::add_fullrequest() {
  // @@protoc_insertion_point(field_add:xclPollCompletion_response.fullrequest)
  return fullrequest_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPollCompletion_response_request >&
xclPollCompletion_response::fullrequest() const {
  // @@protoc_insertion_point(field_list:xclPollCompletion_response.fullrequest)
  return fullrequest_;
}

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

// xclDestroyQueue_call

// optional uint64 q_handle = 1;
inline bool xclDestroyQueue_call::has_q_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclDestroyQueue_call::clear_q_handle() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclDestroyQueue_call::q_handle() const {
  // @@protoc_insertion_point(field_get:xclDestroyQueue_call.q_handle)
  return q_handle_;
}
inline void xclDestroyQueue_call::set_q_handle(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  q_handle_ = value;
  // @@protoc_insertion_point(field_set:xclDestroyQueue_call.q_handle)
}

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

// xclDestroyQueue_response

// optional bool success = 1;
inline bool xclDestroyQueue_response::has_success() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclDestroyQueue_response::clear_success() {
  success_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclDestroyQueue_response::success() const {
  // @@protoc_insertion_point(field_get:xclDestroyQueue_response.success)
  return success_;
}
inline void xclDestroyQueue_response::set_success(bool value) {
  _has_bits_[0] |= 0x00000001u;
  success_ = value;
  // @@protoc_insertion_point(field_set:xclDestroyQueue_response.success)
}

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

// xclSetupInstance_call_argflowpair

// optional uint64 arg = 2;
inline bool xclSetupInstance_call_argflowpair::has_arg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclSetupInstance_call_argflowpair::clear_arg() {
  arg_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclSetupInstance_call_argflowpair::arg() const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_call.argflowpair.arg)
  return arg_;
}
inline void xclSetupInstance_call_argflowpair::set_arg(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  arg_ = value;
  // @@protoc_insertion_point(field_set:xclSetupInstance_call.argflowpair.arg)
}

// optional uint64 flow = 3;
inline bool xclSetupInstance_call_argflowpair::has_flow() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclSetupInstance_call_argflowpair::clear_flow() {
  flow_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclSetupInstance_call_argflowpair::flow() const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_call.argflowpair.flow)
  return flow_;
}
inline void xclSetupInstance_call_argflowpair::set_flow(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  flow_ = value;
  // @@protoc_insertion_point(field_set:xclSetupInstance_call.argflowpair.flow)
}

// optional string tag = 4;
inline bool xclSetupInstance_call_argflowpair::has_tag() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclSetupInstance_call_argflowpair::clear_tag() {
  tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclSetupInstance_call_argflowpair::tag() const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_call.argflowpair.tag)
  return tag_.GetNoArena();
}
inline void xclSetupInstance_call_argflowpair::set_tag(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclSetupInstance_call.argflowpair.tag)
}
inline void xclSetupInstance_call_argflowpair::set_tag(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclSetupInstance_call.argflowpair.tag)
}
inline void xclSetupInstance_call_argflowpair::set_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclSetupInstance_call.argflowpair.tag)
}
inline void xclSetupInstance_call_argflowpair::set_tag(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclSetupInstance_call.argflowpair.tag)
}
inline std::string* xclSetupInstance_call_argflowpair::mutable_tag() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclSetupInstance_call.argflowpair.tag)
  return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclSetupInstance_call_argflowpair::release_tag() {
  // @@protoc_insertion_point(field_release:xclSetupInstance_call.argflowpair.tag)
  if (!has_tag()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return tag_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclSetupInstance_call_argflowpair::set_allocated_tag(std::string* tag) {
  if (tag != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag);
  // @@protoc_insertion_point(field_set_allocated:xclSetupInstance_call.argflowpair.tag)
}

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

// xclSetupInstance_call

// optional uint64 route = 1;
inline bool xclSetupInstance_call::has_route() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclSetupInstance_call::clear_route() {
  route_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclSetupInstance_call::route() const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_call.route)
  return route_;
}
inline void xclSetupInstance_call::set_route(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  route_ = value;
  // @@protoc_insertion_point(field_set:xclSetupInstance_call.route)
}

// repeated .xclSetupInstance_call.argflowpair setup = 5;
inline int xclSetupInstance_call::setup_size() const {
  return setup_.size();
}
inline void xclSetupInstance_call::clear_setup() {
  setup_.Clear();
}
inline ::xclSetupInstance_call_argflowpair* xclSetupInstance_call::mutable_setup(int index) {
  // @@protoc_insertion_point(field_mutable:xclSetupInstance_call.setup)
  return setup_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetupInstance_call_argflowpair >*
xclSetupInstance_call::mutable_setup() {
  // @@protoc_insertion_point(field_mutable_list:xclSetupInstance_call.setup)
  return &setup_;
}
inline const ::xclSetupInstance_call_argflowpair& xclSetupInstance_call::setup(int index) const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_call.setup)
  return setup_.Get(index);
}
inline ::xclSetupInstance_call_argflowpair* xclSetupInstance_call::add_setup() {
  // @@protoc_insertion_point(field_add:xclSetupInstance_call.setup)
  return setup_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclSetupInstance_call_argflowpair >&
xclSetupInstance_call::setup() const {
  // @@protoc_insertion_point(field_list:xclSetupInstance_call.setup)
  return setup_;
}

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

// xclSetupInstance_response

// optional bool success = 1;
inline bool xclSetupInstance_response::has_success() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclSetupInstance_response::clear_success() {
  success_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool xclSetupInstance_response::success() const {
  // @@protoc_insertion_point(field_get:xclSetupInstance_response.success)
  return success_;
}
inline void xclSetupInstance_response::set_success(bool value) {
  _has_bits_[0] |= 0x00000001u;
  success_ = value;
  // @@protoc_insertion_point(field_set:xclSetupInstance_response.success)
}

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

// xclPerfMonReadCounters_Streaming_call

// required string slotname = 1;
inline bool xclPerfMonReadCounters_Streaming_call::has_slotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_call::clear_slotname() {
  slotname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPerfMonReadCounters_Streaming_call::slotname() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_call.slotname)
  return slotname_.GetNoArena();
}
inline void xclPerfMonReadCounters_Streaming_call::set_slotname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_call.slotname)
}
inline void xclPerfMonReadCounters_Streaming_call::set_slotname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPerfMonReadCounters_Streaming_call.slotname)
}
inline void xclPerfMonReadCounters_Streaming_call::set_slotname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPerfMonReadCounters_Streaming_call.slotname)
}
inline void xclPerfMonReadCounters_Streaming_call::set_slotname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPerfMonReadCounters_Streaming_call.slotname)
}
inline std::string* xclPerfMonReadCounters_Streaming_call::mutable_slotname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadCounters_Streaming_call.slotname)
  return slotname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPerfMonReadCounters_Streaming_call::release_slotname() {
  // @@protoc_insertion_point(field_release:xclPerfMonReadCounters_Streaming_call.slotname)
  if (!has_slotname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return slotname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPerfMonReadCounters_Streaming_call::set_allocated_slotname(std::string* slotname) {
  if (slotname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  slotname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), slotname);
  // @@protoc_insertion_point(field_set_allocated:xclPerfMonReadCounters_Streaming_call.slotname)
}

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

// xclPerfMonReadCounters_Streaming_response

// optional uint64 str_num_tranx = 7;
inline bool xclPerfMonReadCounters_Streaming_response::has_str_num_tranx() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_response::clear_str_num_tranx() {
  str_num_tranx_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadCounters_Streaming_response::str_num_tranx() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_response.str_num_tranx)
  return str_num_tranx_;
}
inline void xclPerfMonReadCounters_Streaming_response::set_str_num_tranx(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  str_num_tranx_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_response.str_num_tranx)
}

// optional uint64 str_data_bytes = 8;
inline bool xclPerfMonReadCounters_Streaming_response::has_str_data_bytes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_response::clear_str_data_bytes() {
  str_data_bytes_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadCounters_Streaming_response::str_data_bytes() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_response.str_data_bytes)
  return str_data_bytes_;
}
inline void xclPerfMonReadCounters_Streaming_response::set_str_data_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  str_data_bytes_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_response.str_data_bytes)
}

// optional uint64 str_busy_cycles = 9;
inline bool xclPerfMonReadCounters_Streaming_response::has_str_busy_cycles() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_response::clear_str_busy_cycles() {
  str_busy_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadCounters_Streaming_response::str_busy_cycles() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_response.str_busy_cycles)
  return str_busy_cycles_;
}
inline void xclPerfMonReadCounters_Streaming_response::set_str_busy_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  str_busy_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_response.str_busy_cycles)
}

// optional uint64 str_stall_cycles = 10;
inline bool xclPerfMonReadCounters_Streaming_response::has_str_stall_cycles() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_response::clear_str_stall_cycles() {
  str_stall_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadCounters_Streaming_response::str_stall_cycles() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_response.str_stall_cycles)
  return str_stall_cycles_;
}
inline void xclPerfMonReadCounters_Streaming_response::set_str_stall_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  str_stall_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_response.str_stall_cycles)
}

// optional uint64 str_starve_cycles = 11;
inline bool xclPerfMonReadCounters_Streaming_response::has_str_starve_cycles() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void xclPerfMonReadCounters_Streaming_response::clear_str_starve_cycles() {
  str_starve_cycles_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadCounters_Streaming_response::str_starve_cycles() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadCounters_Streaming_response.str_starve_cycles)
  return str_starve_cycles_;
}
inline void xclPerfMonReadCounters_Streaming_response::set_str_starve_cycles(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000010u;
  str_starve_cycles_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadCounters_Streaming_response.str_starve_cycles)
}

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

// xclPerfMonReadTrace_Streaming_call

// optional bool ack = 1;
inline bool xclPerfMonReadTrace_Streaming_call::has_ack() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadTrace_Streaming_call::clear_ack() {
  ack_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool xclPerfMonReadTrace_Streaming_call::ack() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_call.ack)
  return ack_;
}
inline void xclPerfMonReadTrace_Streaming_call::set_ack(bool value) {
  _has_bits_[0] |= 0x00000002u;
  ack_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_Streaming_call.ack)
}

// optional string slotname = 2;
inline bool xclPerfMonReadTrace_Streaming_call::has_slotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadTrace_Streaming_call::clear_slotname() {
  slotname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& xclPerfMonReadTrace_Streaming_call::slotname() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_call.slotname)
  return slotname_.GetNoArena();
}
inline void xclPerfMonReadTrace_Streaming_call::set_slotname(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_Streaming_call.slotname)
}
inline void xclPerfMonReadTrace_Streaming_call::set_slotname(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xclPerfMonReadTrace_Streaming_call.slotname)
}
inline void xclPerfMonReadTrace_Streaming_call::set_slotname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xclPerfMonReadTrace_Streaming_call.slotname)
}
inline void xclPerfMonReadTrace_Streaming_call::set_slotname(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  slotname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xclPerfMonReadTrace_Streaming_call.slotname)
}
inline std::string* xclPerfMonReadTrace_Streaming_call::mutable_slotname() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadTrace_Streaming_call.slotname)
  return slotname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* xclPerfMonReadTrace_Streaming_call::release_slotname() {
  // @@protoc_insertion_point(field_release:xclPerfMonReadTrace_Streaming_call.slotname)
  if (!has_slotname()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return slotname_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void xclPerfMonReadTrace_Streaming_call::set_allocated_slotname(std::string* slotname) {
  if (slotname != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  slotname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), slotname);
  // @@protoc_insertion_point(field_set_allocated:xclPerfMonReadTrace_Streaming_call.slotname)
}

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

// xclPerfMonReadTrace_Streaming_response_events

// optional uint32 eventflags = 3;
inline bool xclPerfMonReadTrace_Streaming_response_events::has_eventflags() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void xclPerfMonReadTrace_Streaming_response_events::clear_eventflags() {
  eventflags_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_Streaming_response_events::eventflags() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_response.events.eventflags)
  return eventflags_;
}
inline void xclPerfMonReadTrace_Streaming_response_events::set_eventflags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  eventflags_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_Streaming_response.events.eventflags)
}

// optional uint32 timestamp = 4;
inline bool xclPerfMonReadTrace_Streaming_response_events::has_timestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void xclPerfMonReadTrace_Streaming_response_events::clear_timestamp() {
  timestamp_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 xclPerfMonReadTrace_Streaming_response_events::timestamp() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_response.events.timestamp)
  return timestamp_;
}
inline void xclPerfMonReadTrace_Streaming_response_events::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_Streaming_response.events.timestamp)
}

// optional uint64 host_timestamp = 5;
inline bool xclPerfMonReadTrace_Streaming_response_events::has_host_timestamp() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void xclPerfMonReadTrace_Streaming_response_events::clear_host_timestamp() {
  host_timestamp_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 xclPerfMonReadTrace_Streaming_response_events::host_timestamp() const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_response.events.host_timestamp)
  return host_timestamp_;
}
inline void xclPerfMonReadTrace_Streaming_response_events::set_host_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000004u;
  host_timestamp_ = value;
  // @@protoc_insertion_point(field_set:xclPerfMonReadTrace_Streaming_response.events.host_timestamp)
}

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

// xclPerfMonReadTrace_Streaming_response

// repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
inline int xclPerfMonReadTrace_Streaming_response::output_data_size() const {
  return output_data_.size();
}
inline void xclPerfMonReadTrace_Streaming_response::clear_output_data() {
  output_data_.Clear();
}
inline ::xclPerfMonReadTrace_Streaming_response_events* xclPerfMonReadTrace_Streaming_response::mutable_output_data(int index) {
  // @@protoc_insertion_point(field_mutable:xclPerfMonReadTrace_Streaming_response.output_data)
  return output_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_Streaming_response_events >*
xclPerfMonReadTrace_Streaming_response::mutable_output_data() {
  // @@protoc_insertion_point(field_mutable_list:xclPerfMonReadTrace_Streaming_response.output_data)
  return &output_data_;
}
inline const ::xclPerfMonReadTrace_Streaming_response_events& xclPerfMonReadTrace_Streaming_response::output_data(int index) const {
  // @@protoc_insertion_point(field_get:xclPerfMonReadTrace_Streaming_response.output_data)
  return output_data_.Get(index);
}
inline ::xclPerfMonReadTrace_Streaming_response_events* xclPerfMonReadTrace_Streaming_response::add_output_data() {
  // @@protoc_insertion_point(field_add:xclPerfMonReadTrace_Streaming_response.output_data)
  return output_data_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xclPerfMonReadTrace_Streaming_response_events >&
xclPerfMonReadTrace_Streaming_response::output_data() const {
  // @@protoc_insertion_point(field_list:xclPerfMonReadTrace_Streaming_response.output_data)
  return output_data_;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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