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

#include "rpc_messages.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rpc_5fmessages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto;
class call_packet_infoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<call_packet_info> _instance;
} _call_packet_info_default_instance_;
class response_packet_infoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<response_packet_info> _instance;
} _response_packet_info_default_instance_;
class xclSetEnvironment_call_namevaluepairDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetEnvironment_call_namevaluepair> _instance;
} _xclSetEnvironment_call_namevaluepair_default_instance_;
class xclSetEnvironment_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetEnvironment_call> _instance;
} _xclSetEnvironment_call_default_instance_;
class xclSetEnvironment_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetEnvironment_response> _instance;
} _xclSetEnvironment_response_default_instance_;
class xclLoadBitstream_call_ddrbankDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclLoadBitstream_call_ddrbank> _instance;
} _xclLoadBitstream_call_ddrbank_default_instance_;
class xclLoadBitstream_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclLoadBitstream_call> _instance;
} _xclLoadBitstream_call_default_instance_;
class xclLoadBitstream_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclLoadBitstream_response> _instance;
} _xclLoadBitstream_response_default_instance_;
class xclAllocDeviceBuffer_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclAllocDeviceBuffer_call> _instance;
} _xclAllocDeviceBuffer_call_default_instance_;
class xclAllocDeviceBuffer_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclAllocDeviceBuffer_response> _instance;
} _xclAllocDeviceBuffer_response_default_instance_;
class xclFreeDeviceBuffer_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclFreeDeviceBuffer_call> _instance;
} _xclFreeDeviceBuffer_call_default_instance_;
class xclFreeDeviceBuffer_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclFreeDeviceBuffer_response> _instance;
} _xclFreeDeviceBuffer_response_default_instance_;
class xclClose_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclClose_call> _instance;
} _xclClose_call_default_instance_;
class xclClose_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclClose_response> _instance;
} _xclClose_response_default_instance_;
class xclCopyBufferHost2Device_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBufferHost2Device_call> _instance;
} _xclCopyBufferHost2Device_call_default_instance_;
class xclCopyBufferHost2Device_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBufferHost2Device_response> _instance;
} _xclCopyBufferHost2Device_response_default_instance_;
class xclCopyBufferDevice2Host_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBufferDevice2Host_call> _instance;
} _xclCopyBufferDevice2Host_call_default_instance_;
class xclCopyBufferDevice2Host_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBufferDevice2Host_response> _instance;
} _xclCopyBufferDevice2Host_response_default_instance_;
class xclWriteAddrSpaceDeviceRam_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteAddrSpaceDeviceRam_call> _instance;
} _xclWriteAddrSpaceDeviceRam_call_default_instance_;
class xclWriteAddrSpaceDeviceRam_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteAddrSpaceDeviceRam_response> _instance;
} _xclWriteAddrSpaceDeviceRam_response_default_instance_;
class xclWriteAddrKernelCtrl_call_kernelInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteAddrKernelCtrl_call_kernelInfo> _instance;
} _xclWriteAddrKernelCtrl_call_kernelInfo_default_instance_;
class xclWriteAddrKernelCtrl_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteAddrKernelCtrl_call> _instance;
} _xclWriteAddrKernelCtrl_call_default_instance_;
class xclWriteAddrKernelCtrl_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteAddrKernelCtrl_response> _instance;
} _xclWriteAddrKernelCtrl_response_default_instance_;
class xclReadAddrSpaceDeviceRam_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadAddrSpaceDeviceRam_call> _instance;
} _xclReadAddrSpaceDeviceRam_call_default_instance_;
class xclReadAddrSpaceDeviceRam_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadAddrSpaceDeviceRam_response> _instance;
} _xclReadAddrSpaceDeviceRam_response_default_instance_;
class xclReadAddrKernelCtrl_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadAddrKernelCtrl_call> _instance;
} _xclReadAddrKernelCtrl_call_default_instance_;
class xclReadAddrKernelCtrl_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadAddrKernelCtrl_response> _instance;
} _xclReadAddrKernelCtrl_response_default_instance_;
class xclPerfMonReadCounters_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadCounters_call> _instance;
} _xclPerfMonReadCounters_call_default_instance_;
class xclPerfMonReadCounters_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadCounters_response> _instance;
} _xclPerfMonReadCounters_response_default_instance_;
class xclPerfMonGetTraceCount_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonGetTraceCount_call> _instance;
} _xclPerfMonGetTraceCount_call_default_instance_;
class xclPerfMonGetTraceCount_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonGetTraceCount_response> _instance;
} _xclPerfMonGetTraceCount_response_default_instance_;
class xclPerfMonReadTrace_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_call> _instance;
} _xclPerfMonReadTrace_call_default_instance_;
class xclPerfMonReadTrace_response_eventsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_response_events> _instance;
} _xclPerfMonReadTrace_response_events_default_instance_;
class xclPerfMonReadTrace_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_response> _instance;
} _xclPerfMonReadTrace_response_default_instance_;
class ddr_mem_msgDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ddr_mem_msg> _instance;
} _ddr_mem_msg_default_instance_;
class xclGetDeviceTimestamp_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclGetDeviceTimestamp_call> _instance;
} _xclGetDeviceTimestamp_call_default_instance_;
class xclGetDeviceTimestamp_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclGetDeviceTimestamp_response> _instance;
} _xclGetDeviceTimestamp_response_default_instance_;
class xclReadBusStatus_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadBusStatus_call> _instance;
} _xclReadBusStatus_call_default_instance_;
class xclReadBusStatus_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadBusStatus_response> _instance;
} _xclReadBusStatus_response_default_instance_;
class xclGetDebugMessages_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclGetDebugMessages_call> _instance;
} _xclGetDebugMessages_call_default_instance_;
class xclGetDebugMessages_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclGetDebugMessages_response> _instance;
} _xclGetDebugMessages_response_default_instance_;
class xclImportBO_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclImportBO_call> _instance;
} _xclImportBO_call_default_instance_;
class xclImportBO_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclImportBO_response> _instance;
} _xclImportBO_response_default_instance_;
class xclCopyBO_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBO_call> _instance;
} _xclCopyBO_call_default_instance_;
class xclCopyBO_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCopyBO_response> _instance;
} _xclCopyBO_response_default_instance_;
class xclCreateQueue_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCreateQueue_call> _instance;
} _xclCreateQueue_call_default_instance_;
class xclCreateQueue_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclCreateQueue_response> _instance;
} _xclCreateQueue_response_default_instance_;
class xclWriteQueue_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteQueue_call> _instance;
} _xclWriteQueue_call_default_instance_;
class xclWriteQueue_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclWriteQueue_response> _instance;
} _xclWriteQueue_response_default_instance_;
class xclReadQueue_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadQueue_call> _instance;
} _xclReadQueue_call_default_instance_;
class xclReadQueue_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclReadQueue_response> _instance;
} _xclReadQueue_response_default_instance_;
class xclPollCompletion_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPollCompletion_call> _instance;
} _xclPollCompletion_call_default_instance_;
class xclPollCompletion_response_requestDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPollCompletion_response_request> _instance;
} _xclPollCompletion_response_request_default_instance_;
class xclPollCompletion_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPollCompletion_response> _instance;
} _xclPollCompletion_response_default_instance_;
class xclDestroyQueue_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclDestroyQueue_call> _instance;
} _xclDestroyQueue_call_default_instance_;
class xclDestroyQueue_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclDestroyQueue_response> _instance;
} _xclDestroyQueue_response_default_instance_;
class xclSetupInstance_call_argflowpairDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetupInstance_call_argflowpair> _instance;
} _xclSetupInstance_call_argflowpair_default_instance_;
class xclSetupInstance_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetupInstance_call> _instance;
} _xclSetupInstance_call_default_instance_;
class xclSetupInstance_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclSetupInstance_response> _instance;
} _xclSetupInstance_response_default_instance_;
class xclPerfMonReadCounters_Streaming_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadCounters_Streaming_call> _instance;
} _xclPerfMonReadCounters_Streaming_call_default_instance_;
class xclPerfMonReadCounters_Streaming_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadCounters_Streaming_response> _instance;
} _xclPerfMonReadCounters_Streaming_response_default_instance_;
class xclPerfMonReadTrace_Streaming_callDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_Streaming_call> _instance;
} _xclPerfMonReadTrace_Streaming_call_default_instance_;
class xclPerfMonReadTrace_Streaming_response_eventsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_Streaming_response_events> _instance;
} _xclPerfMonReadTrace_Streaming_response_events_default_instance_;
class xclPerfMonReadTrace_Streaming_responseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<xclPerfMonReadTrace_Streaming_response> _instance;
} _xclPerfMonReadTrace_Streaming_response_default_instance_;
static void InitDefaultsscc_info_call_packet_info_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_call_packet_info_default_instance_;
    new (ptr) ::call_packet_info();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::call_packet_info::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_call_packet_info_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_call_packet_info_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_ddr_mem_msg_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_ddr_mem_msg_default_instance_;
    new (ptr) ::ddr_mem_msg();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::ddr_mem_msg::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ddr_mem_msg_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_ddr_mem_msg_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_response_packet_info_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_response_packet_info_default_instance_;
    new (ptr) ::response_packet_info();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::response_packet_info::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_response_packet_info_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_response_packet_info_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclAllocDeviceBuffer_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclAllocDeviceBuffer_call_default_instance_;
    new (ptr) ::xclAllocDeviceBuffer_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclAllocDeviceBuffer_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclAllocDeviceBuffer_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclAllocDeviceBuffer_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclAllocDeviceBuffer_response_default_instance_;
    new (ptr) ::xclAllocDeviceBuffer_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclAllocDeviceBuffer_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclClose_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclClose_call_default_instance_;
    new (ptr) ::xclClose_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclClose_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclClose_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclClose_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclClose_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclClose_response_default_instance_;
    new (ptr) ::xclClose_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclClose_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclClose_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclClose_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBO_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBO_call_default_instance_;
    new (ptr) ::xclCopyBO_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBO_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBO_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBO_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBO_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBO_response_default_instance_;
    new (ptr) ::xclCopyBO_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBO_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBO_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBO_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBufferDevice2Host_call_default_instance_;
    new (ptr) ::xclCopyBufferDevice2Host_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBufferDevice2Host_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBufferDevice2Host_response_default_instance_;
    new (ptr) ::xclCopyBufferDevice2Host_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBufferDevice2Host_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBufferHost2Device_call_default_instance_;
    new (ptr) ::xclCopyBufferHost2Device_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBufferHost2Device_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCopyBufferHost2Device_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCopyBufferHost2Device_response_default_instance_;
    new (ptr) ::xclCopyBufferHost2Device_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCopyBufferHost2Device_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCopyBufferHost2Device_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCopyBufferHost2Device_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCreateQueue_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCreateQueue_call_default_instance_;
    new (ptr) ::xclCreateQueue_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCreateQueue_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCreateQueue_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCreateQueue_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclCreateQueue_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclCreateQueue_response_default_instance_;
    new (ptr) ::xclCreateQueue_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclCreateQueue_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclCreateQueue_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclCreateQueue_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclDestroyQueue_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclDestroyQueue_call_default_instance_;
    new (ptr) ::xclDestroyQueue_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclDestroyQueue_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclDestroyQueue_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclDestroyQueue_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclDestroyQueue_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclDestroyQueue_response_default_instance_;
    new (ptr) ::xclDestroyQueue_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclDestroyQueue_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclDestroyQueue_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclDestroyQueue_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclFreeDeviceBuffer_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclFreeDeviceBuffer_call_default_instance_;
    new (ptr) ::xclFreeDeviceBuffer_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclFreeDeviceBuffer_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclFreeDeviceBuffer_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclFreeDeviceBuffer_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclFreeDeviceBuffer_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclFreeDeviceBuffer_response_default_instance_;
    new (ptr) ::xclFreeDeviceBuffer_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclFreeDeviceBuffer_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclFreeDeviceBuffer_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclFreeDeviceBuffer_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclGetDebugMessages_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclGetDebugMessages_call_default_instance_;
    new (ptr) ::xclGetDebugMessages_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclGetDebugMessages_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclGetDebugMessages_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclGetDebugMessages_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclGetDebugMessages_response_default_instance_;
    new (ptr) ::xclGetDebugMessages_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclGetDebugMessages_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclGetDeviceTimestamp_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclGetDeviceTimestamp_call_default_instance_;
    new (ptr) ::xclGetDeviceTimestamp_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclGetDeviceTimestamp_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclGetDeviceTimestamp_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclGetDeviceTimestamp_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclGetDeviceTimestamp_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclGetDeviceTimestamp_response_default_instance_;
    new (ptr) ::xclGetDeviceTimestamp_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclGetDeviceTimestamp_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclGetDeviceTimestamp_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclGetDeviceTimestamp_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclImportBO_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclImportBO_call_default_instance_;
    new (ptr) ::xclImportBO_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclImportBO_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclImportBO_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclImportBO_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclImportBO_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclImportBO_response_default_instance_;
    new (ptr) ::xclImportBO_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclImportBO_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclImportBO_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclImportBO_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclLoadBitstream_call_default_instance_;
    new (ptr) ::xclLoadBitstream_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclLoadBitstream_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto}, {
      &scc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclLoadBitstream_call_ddrbank_default_instance_;
    new (ptr) ::xclLoadBitstream_call_ddrbank();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclLoadBitstream_call_ddrbank::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclLoadBitstream_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclLoadBitstream_response_default_instance_;
    new (ptr) ::xclLoadBitstream_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclLoadBitstream_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclLoadBitstream_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclLoadBitstream_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonGetTraceCount_call_default_instance_;
    new (ptr) ::xclPerfMonGetTraceCount_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonGetTraceCount_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonGetTraceCount_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonGetTraceCount_response_default_instance_;
    new (ptr) ::xclPerfMonGetTraceCount_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonGetTraceCount_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonGetTraceCount_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonGetTraceCount_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadCounters_Streaming_call_default_instance_;
    new (ptr) ::xclPerfMonReadCounters_Streaming_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadCounters_Streaming_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadCounters_Streaming_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadCounters_Streaming_response_default_instance_;
    new (ptr) ::xclPerfMonReadCounters_Streaming_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadCounters_Streaming_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadCounters_Streaming_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadCounters_Streaming_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadCounters_call_default_instance_;
    new (ptr) ::xclPerfMonReadCounters_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadCounters_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadCounters_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadCounters_response_default_instance_;
    new (ptr) ::xclPerfMonReadCounters_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadCounters_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadCounters_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadCounters_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_Streaming_call_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_Streaming_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_Streaming_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_Streaming_response_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_Streaming_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_Streaming_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto}, {
      &scc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_Streaming_response_events_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_Streaming_response_events();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_Streaming_response_events::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_call_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_response_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto}, {
      &scc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPerfMonReadTrace_response_events_default_instance_;
    new (ptr) ::xclPerfMonReadTrace_response_events();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPerfMonReadTrace_response_events::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPollCompletion_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPollCompletion_call_default_instance_;
    new (ptr) ::xclPollCompletion_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPollCompletion_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPollCompletion_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPollCompletion_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclPollCompletion_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPollCompletion_response_default_instance_;
    new (ptr) ::xclPollCompletion_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPollCompletion_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclPollCompletion_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclPollCompletion_response_rpc_5fmessages_2eproto}, {
      &scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclPollCompletion_response_request_default_instance_;
    new (ptr) ::xclPollCompletion_response_request();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclPollCompletion_response_request::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadAddrKernelCtrl_call_default_instance_;
    new (ptr) ::xclReadAddrKernelCtrl_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadAddrKernelCtrl_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadAddrKernelCtrl_response_default_instance_;
    new (ptr) ::xclReadAddrKernelCtrl_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadAddrKernelCtrl_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadAddrSpaceDeviceRam_call_default_instance_;
    new (ptr) ::xclReadAddrSpaceDeviceRam_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadAddrSpaceDeviceRam_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadAddrSpaceDeviceRam_response_default_instance_;
    new (ptr) ::xclReadAddrSpaceDeviceRam_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadAddrSpaceDeviceRam_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadBusStatus_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadBusStatus_call_default_instance_;
    new (ptr) ::xclReadBusStatus_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadBusStatus_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadBusStatus_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadBusStatus_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadBusStatus_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadBusStatus_response_default_instance_;
    new (ptr) ::xclReadBusStatus_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadBusStatus_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadBusStatus_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadBusStatus_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadQueue_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadQueue_call_default_instance_;
    new (ptr) ::xclReadQueue_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadQueue_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadQueue_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadQueue_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclReadQueue_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclReadQueue_response_default_instance_;
    new (ptr) ::xclReadQueue_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclReadQueue_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclReadQueue_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclReadQueue_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetEnvironment_call_default_instance_;
    new (ptr) ::xclSetEnvironment_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetEnvironment_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto}, {
      &scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetEnvironment_call_namevaluepair_default_instance_;
    new (ptr) ::xclSetEnvironment_call_namevaluepair();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetEnvironment_call_namevaluepair::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclSetEnvironment_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetEnvironment_response_default_instance_;
    new (ptr) ::xclSetEnvironment_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetEnvironment_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetEnvironment_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclSetEnvironment_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclSetupInstance_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetupInstance_call_default_instance_;
    new (ptr) ::xclSetupInstance_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetupInstance_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclSetupInstance_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclSetupInstance_call_rpc_5fmessages_2eproto}, {
      &scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetupInstance_call_argflowpair_default_instance_;
    new (ptr) ::xclSetupInstance_call_argflowpair();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetupInstance_call_argflowpair::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclSetupInstance_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclSetupInstance_response_default_instance_;
    new (ptr) ::xclSetupInstance_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclSetupInstance_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclSetupInstance_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclSetupInstance_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteAddrKernelCtrl_call_default_instance_;
    new (ptr) ::xclWriteAddrKernelCtrl_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteAddrKernelCtrl_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto}, {
      &scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto.base,}};

static void InitDefaultsscc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteAddrKernelCtrl_call_kernelInfo_default_instance_;
    new (ptr) ::xclWriteAddrKernelCtrl_call_kernelInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteAddrKernelCtrl_call_kernelInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteAddrKernelCtrl_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteAddrKernelCtrl_response_default_instance_;
    new (ptr) ::xclWriteAddrKernelCtrl_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteAddrKernelCtrl_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteAddrKernelCtrl_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteAddrKernelCtrl_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteAddrSpaceDeviceRam_call_default_instance_;
    new (ptr) ::xclWriteAddrSpaceDeviceRam_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteAddrSpaceDeviceRam_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteAddrSpaceDeviceRam_response_default_instance_;
    new (ptr) ::xclWriteAddrSpaceDeviceRam_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteAddrSpaceDeviceRam_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteQueue_call_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteQueue_call_default_instance_;
    new (ptr) ::xclWriteQueue_call();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteQueue_call::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteQueue_call_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteQueue_call_rpc_5fmessages_2eproto}, {}};

static void InitDefaultsscc_info_xclWriteQueue_response_rpc_5fmessages_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_xclWriteQueue_response_default_instance_;
    new (ptr) ::xclWriteQueue_response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::xclWriteQueue_response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_xclWriteQueue_response_rpc_5fmessages_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_xclWriteQueue_response_rpc_5fmessages_2eproto}, {}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_rpc_5fmessages_2eproto[64];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_rpc_5fmessages_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_rpc_5fmessages_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_rpc_5fmessages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::call_packet_info, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::call_packet_info, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::call_packet_info, size_),
  PROTOBUF_FIELD_OFFSET(::call_packet_info, xcl_api_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::response_packet_info, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::response_packet_info, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::response_packet_info, size_),
  PROTOBUF_FIELD_OFFSET(::response_packet_info, xcl_api_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call_namevaluepair, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call_namevaluepair, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call_namevaluepair, name_),
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call_namevaluepair, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_call, environment_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetEnvironment_response, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call_ddrbank, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call_ddrbank, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call_ddrbank, size_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, xmlfile_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, dlopenfilename_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, devicename_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, devicedirectory_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, binarydirectory_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, verbose_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_call, ddrbanks_),
  0,
  1,
  2,
  3,
  4,
  5,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclLoadBitstream_response, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_call, ddraddress_),
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_call, peertopeer_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_response, ack_),
  PROTOBUF_FIELD_OFFSET(::xclAllocDeviceBuffer_response, filename_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_call, ddraddress_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclFreeDeviceBuffer_response, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclClose_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclClose_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclClose_call, xcldevicehandle_),
  PROTOBUF_FIELD_OFFSET(::xclClose_call, closeall_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclClose_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclClose_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclClose_response, valid_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, xcldevicehandle_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, dest_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, src_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, seek_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_call, space_),
  0,
  2,
  1,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferHost2Device_response, size_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, xcldevicehandle_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, dest_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, src_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, skip_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_call, space_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_response, size_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBufferDevice2Host_response, dest_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_call, addr_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_call, data_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrSpaceDeviceRam_response, valid_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call_kernelInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call_kernelInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call_kernelInfo, addr_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call_kernelInfo, size_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call_kernelInfo, name_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, addr_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, data_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_call, kernel_info_),
  1,
  2,
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteAddrKernelCtrl_response, valid_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_call, addr_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_call, data_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_response, valid_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrSpaceDeviceRam_response, data_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_call, addr_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_call, data_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_response, valid_),
  PROTOBUF_FIELD_OFFSET(::xclReadAddrKernelCtrl_response, data_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_call, slotname_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_call, accel_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, wr_byte_count_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, wr_trans_count_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, total_wr_latency_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, rd_byte_count_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, rd_trans_count_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_response, total_rd_latency_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_call, ack_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_call, slotname_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_call, accel_),
  1,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonGetTraceCount_response, no_of_samples_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_call, ack_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_call, slotname_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_call, accel_),
  1,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, awlen_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, arlen_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, eventflags_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, timestamp_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, host_timestamp_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, rd_bytes_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response_events, wr_bytes_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_response, output_data_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, data_),
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, size_),
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, strb_data_),
  PROTOBUF_FIELD_OFFSET(::ddr_mem_msg, fullsize_),
  0,
  2,
  1,
  3,
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_call, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclGetDeviceTimestamp_response, device_timestamp_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_call, slot_n_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, uncomplete_rd_cycles_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, uncomplete_wr_cycles_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, idle_bus_cycles_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, uncomplete_rd_id_),
  PROTOBUF_FIELD_OFFSET(::xclReadBusStatus_response, uncomplete_wr_id_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_call, ack_),
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_call, force_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_response, display_msgs_),
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_response, log_msgs_),
  PROTOBUF_FIELD_OFFSET(::xclGetDebugMessages_response, stop_msgs_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::xclImportBO_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclImportBO_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclImportBO_call, dst_filename_),
  PROTOBUF_FIELD_OFFSET(::xclImportBO_call, offset_),
  PROTOBUF_FIELD_OFFSET(::xclImportBO_call, size_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::xclImportBO_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclImportBO_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclImportBO_response, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, src_handle_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, dst_filename_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, src_offset_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_call, dst_offset_),
  1,
  0,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCopyBO_response, ack_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, write_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, type_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, state_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, route_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, flow_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, qsize_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, desc_size_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_call, flags_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclCreateQueue_response, q_handle_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, q_handle_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, src_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, req_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, nonblocking_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_call, eot_),
  1,
  0,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclWriteQueue_response, written_size_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, q_handle_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, dest_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, size_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, req_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, nonblocking_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_call, eot_),
  1,
  0,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_response, dest_),
  PROTOBUF_FIELD_OFFSET(::xclReadQueue_response, size_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_call, req_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response_request, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response_request, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response_request, dest_),
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response_request, size_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPollCompletion_response, fullrequest_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_call, q_handle_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclDestroyQueue_response, success_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call_argflowpair, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call_argflowpair, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call_argflowpair, arg_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call_argflowpair, flow_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call_argflowpair, tag_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call, route_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_call, setup_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclSetupInstance_response, success_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_call, slotname_),
  0,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, str_num_tranx_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, str_data_bytes_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, str_busy_cycles_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, str_stall_cycles_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadCounters_Streaming_response, str_starve_cycles_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_call, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_call, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_call, ack_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_call, slotname_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response_events, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response_events, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response_events, eventflags_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response_events, timestamp_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response_events, host_timestamp_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::xclPerfMonReadTrace_Streaming_response, output_data_),
  ~0u,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 7, sizeof(::call_packet_info)},
  { 9, 16, sizeof(::response_packet_info)},
  { 18, 25, sizeof(::xclSetEnvironment_call_namevaluepair)},
  { 27, 33, sizeof(::xclSetEnvironment_call)},
  { 34, 40, sizeof(::xclSetEnvironment_response)},
  { 41, 47, sizeof(::xclLoadBitstream_call_ddrbank)},
  { 48, 60, sizeof(::xclLoadBitstream_call)},
  { 67, 73, sizeof(::xclLoadBitstream_response)},
  { 74, 82, sizeof(::xclAllocDeviceBuffer_call)},
  { 85, 92, sizeof(::xclAllocDeviceBuffer_response)},
  { 94, 100, sizeof(::xclFreeDeviceBuffer_call)},
  { 101, 107, sizeof(::xclFreeDeviceBuffer_response)},
  { 108, 115, sizeof(::xclClose_call)},
  { 117, 123, sizeof(::xclClose_response)},
  { 124, 135, sizeof(::xclCopyBufferHost2Device_call)},
  { 141, 147, sizeof(::xclCopyBufferHost2Device_response)},
  { 148, 159, sizeof(::xclCopyBufferDevice2Host_call)},
  { 165, 172, sizeof(::xclCopyBufferDevice2Host_response)},
  { 174, 182, sizeof(::xclWriteAddrSpaceDeviceRam_call)},
  { 185, 191, sizeof(::xclWriteAddrSpaceDeviceRam_response)},
  { 192, 200, sizeof(::xclWriteAddrKernelCtrl_call_kernelInfo)},
  { 203, 212, sizeof(::xclWriteAddrKernelCtrl_call)},
  { 216, 222, sizeof(::xclWriteAddrKernelCtrl_response)},
  { 223, 231, sizeof(::xclReadAddrSpaceDeviceRam_call)},
  { 234, 241, sizeof(::xclReadAddrSpaceDeviceRam_response)},
  { 243, 251, sizeof(::xclReadAddrKernelCtrl_call)},
  { 254, 261, sizeof(::xclReadAddrKernelCtrl_response)},
  { 263, 270, sizeof(::xclPerfMonReadCounters_call)},
  { 272, 283, sizeof(::xclPerfMonReadCounters_response)},
  { 289, 297, sizeof(::xclPerfMonGetTraceCount_call)},
  { 300, 306, sizeof(::xclPerfMonGetTraceCount_response)},
  { 307, 315, sizeof(::xclPerfMonReadTrace_call)},
  { 318, 330, sizeof(::xclPerfMonReadTrace_response_events)},
  { 337, 343, sizeof(::xclPerfMonReadTrace_response)},
  { 344, 353, sizeof(::ddr_mem_msg)},
  { 357, 363, sizeof(::xclGetDeviceTimestamp_call)},
  { 364, 370, sizeof(::xclGetDeviceTimestamp_response)},
  { 371, 377, sizeof(::xclReadBusStatus_call)},
  { 378, 388, sizeof(::xclReadBusStatus_response)},
  { 393, 400, sizeof(::xclGetDebugMessages_call)},
  { 402, 410, sizeof(::xclGetDebugMessages_response)},
  { 413, 421, sizeof(::xclImportBO_call)},
  { 424, 430, sizeof(::xclImportBO_response)},
  { 431, 441, sizeof(::xclCopyBO_call)},
  { 446, 452, sizeof(::xclCopyBO_response)},
  { 453, 466, sizeof(::xclCreateQueue_call)},
  { 474, 480, sizeof(::xclCreateQueue_response)},
  { 481, 492, sizeof(::xclWriteQueue_call)},
  { 498, 504, sizeof(::xclWriteQueue_response)},
  { 505, 516, sizeof(::xclReadQueue_call)},
  { 522, 529, sizeof(::xclReadQueue_response)},
  { 531, 537, sizeof(::xclPollCompletion_call)},
  { 538, 545, sizeof(::xclPollCompletion_response_request)},
  { 547, 553, sizeof(::xclPollCompletion_response)},
  { 554, 560, sizeof(::xclDestroyQueue_call)},
  { 561, 567, sizeof(::xclDestroyQueue_response)},
  { 568, 576, sizeof(::xclSetupInstance_call_argflowpair)},
  { 579, 586, sizeof(::xclSetupInstance_call)},
  { 588, 594, sizeof(::xclSetupInstance_response)},
  { 595, 601, sizeof(::xclPerfMonReadCounters_Streaming_call)},
  { 602, 612, sizeof(::xclPerfMonReadCounters_Streaming_response)},
  { 617, 624, sizeof(::xclPerfMonReadTrace_Streaming_call)},
  { 626, 634, sizeof(::xclPerfMonReadTrace_Streaming_response_events)},
  { 637, 643, sizeof(::xclPerfMonReadTrace_Streaming_response)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_call_packet_info_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_response_packet_info_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetEnvironment_call_namevaluepair_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetEnvironment_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetEnvironment_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclLoadBitstream_call_ddrbank_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclLoadBitstream_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclLoadBitstream_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclAllocDeviceBuffer_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclAllocDeviceBuffer_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclFreeDeviceBuffer_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclFreeDeviceBuffer_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclClose_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclClose_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBufferHost2Device_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBufferHost2Device_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBufferDevice2Host_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBufferDevice2Host_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteAddrSpaceDeviceRam_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteAddrSpaceDeviceRam_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteAddrKernelCtrl_call_kernelInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteAddrKernelCtrl_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteAddrKernelCtrl_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadAddrSpaceDeviceRam_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadAddrSpaceDeviceRam_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadAddrKernelCtrl_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadAddrKernelCtrl_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadCounters_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadCounters_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonGetTraceCount_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonGetTraceCount_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_response_events_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_ddr_mem_msg_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclGetDeviceTimestamp_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclGetDeviceTimestamp_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadBusStatus_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadBusStatus_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclGetDebugMessages_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclGetDebugMessages_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclImportBO_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclImportBO_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBO_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCopyBO_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCreateQueue_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclCreateQueue_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteQueue_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclWriteQueue_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadQueue_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclReadQueue_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPollCompletion_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPollCompletion_response_request_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPollCompletion_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclDestroyQueue_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclDestroyQueue_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetupInstance_call_argflowpair_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetupInstance_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclSetupInstance_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadCounters_Streaming_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadCounters_Streaming_response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_Streaming_call_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_Streaming_response_events_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_xclPerfMonReadTrace_Streaming_response_default_instance_),
};

const char descriptor_table_protodef_rpc_5fmessages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\022rpc_messages.proto\"1\n\020call_packet_info"
  "\022\014\n\004size\030\001 \002(\006\022\017\n\007xcl_api\030\002 \001(\007\"5\n\024respo"
  "nse_packet_info\022\014\n\004size\030\001 \002(\006\022\017\n\007xcl_api"
  "\030\002 \001(\007\"\202\001\n\026xclSetEnvironment_call\022:\n\013env"
  "ironment\030\003 \003(\0132%.xclSetEnvironment_call."
  "namevaluepair\032,\n\rnamevaluepair\022\014\n\004name\030\001"
  " \001(\t\022\r\n\005value\030\002 \001(\t\")\n\032xclSetEnvironment"
  "_response\022\013\n\003ack\030\001 \001(\010\"\342\001\n\025xclLoadBitstr"
  "eam_call\022\017\n\007xmlfile\030\001 \002(\014\022\026\n\016dlopenfilen"
  "ame\030\002 \002(\014\022\022\n\ndevicename\030\003 \002(\014\022\027\n\017deviced"
  "irectory\030\004 \002(\014\022\027\n\017binarydirectory\030\005 \002(\014\022"
  "\017\n\007verbose\030\006 \002(\010\0220\n\010ddrbanks\030\010 \003(\0132\036.xcl"
  "LoadBitstream_call.ddrbank\032\027\n\007ddrbank\022\014\n"
  "\004size\030\007 \001(\004\"(\n\031xclLoadBitstream_response"
  "\022\013\n\003ack\030\001 \002(\010\"Q\n\031xclAllocDeviceBuffer_ca"
  "ll\022\022\n\nddraddress\030\001 \002(\004\022\014\n\004size\030\002 \002(\004\022\022\n\n"
  "peertopeer\030\003 \001(\010\">\n\035xclAllocDeviceBuffer"
  "_response\022\013\n\003ack\030\001 \002(\010\022\020\n\010filename\030\002 \001(\t"
  "\".\n\030xclFreeDeviceBuffer_call\022\022\n\nddraddre"
  "ss\030\001 \002(\004\"+\n\034xclFreeDeviceBuffer_response"
  "\022\013\n\003ack\030\001 \002(\010\":\n\rxclClose_call\022\027\n\017xclDev"
  "iceHandle\030\002 \001(\014\022\020\n\010closeall\030\003 \001(\010\"\"\n\021xcl"
  "Close_response\022\r\n\005valid\030\001 \002(\010\"~\n\035xclCopy"
  "BufferHost2Device_call\022\027\n\017xclDeviceHandl"
  "e\030\002 \002(\014\022\014\n\004dest\030\003 \002(\004\022\013\n\003src\030\004 \002(\014\022\014\n\004si"
  "ze\030\005 \002(\004\022\014\n\004seek\030\006 \002(\004\022\r\n\005space\030\007 \001(\r\"1\n"
  "!xclCopyBufferHost2Device_response\022\014\n\004si"
  "ze\030\001 \002(\004\"~\n\035xclCopyBufferDevice2Host_cal"
  "l\022\027\n\017xclDeviceHandle\030\002 \002(\014\022\014\n\004dest\030\003 \002(\014"
  "\022\013\n\003src\030\004 \002(\004\022\014\n\004size\030\005 \002(\004\022\014\n\004skip\030\006 \002("
  "\004\022\r\n\005space\030\007 \001(\r\"\?\n!xclCopyBufferDevice2"
  "Host_response\022\014\n\004size\030\001 \002(\004\022\014\n\004dest\030\002 \002("
  "\014\"K\n\037xclWriteAddrSpaceDeviceRam_call\022\014\n\004"
  "addr\030\002 \002(\004\022\014\n\004size\030\003 \002(\r\022\014\n\004data\030\004 \002(\014\"4"
  "\n#xclWriteAddrSpaceDeviceRam_response\022\r\n"
  "\005valid\030\001 \002(\010\"\275\001\n\033xclWriteAddrKernelCtrl_"
  "call\022\014\n\004addr\030\002 \002(\004\022\014\n\004size\030\003 \002(\r\022\014\n\004data"
  "\030\004 \002(\014\022<\n\013kernel_info\030\005 \003(\0132\'.xclWriteAd"
  "drKernelCtrl_call.kernelInfo\0326\n\nkernelIn"
  "fo\022\014\n\004addr\030\001 \001(\004\022\014\n\004size\030\002 \001(\r\022\014\n\004name\030\003"
  " \001(\t\"0\n\037xclWriteAddrKernelCtrl_response\022"
  "\r\n\005valid\030\001 \002(\010\"J\n\036xclReadAddrSpaceDevice"
  "Ram_call\022\014\n\004addr\030\002 \002(\004\022\014\n\004size\030\003 \002(\r\022\014\n\004"
  "data\030\004 \001(\014\"A\n\"xclReadAddrSpaceDeviceRam_"
  "response\022\r\n\005valid\030\001 \002(\010\022\014\n\004data\030\002 \001(\014\"F\n"
  "\032xclReadAddrKernelCtrl_call\022\014\n\004addr\030\002 \002("
  "\004\022\014\n\004size\030\003 \002(\r\022\014\n\004data\030\004 \001(\014\"=\n\036xclRead"
  "AddrKernelCtrl_response\022\r\n\005valid\030\001 \002(\010\022\014"
  "\n\004data\030\002 \001(\014\">\n\033xclPerfMonReadCounters_c"
  "all\022\020\n\010slotname\030\001 \002(\t\022\r\n\005accel\030\002 \001(\010\"\263\001\n"
  "\037xclPerfMonReadCounters_response\022\025\n\rwr_b"
  "yte_count\030\001 \001(\r\022\026\n\016wr_trans_count\030\002 \001(\r\022"
  "\030\n\020total_wr_latency\030\003 \001(\r\022\025\n\rrd_byte_cou"
  "nt\030\004 \001(\r\022\026\n\016rd_trans_count\030\005 \001(\r\022\030\n\020tota"
  "l_rd_latency\030\006 \001(\r\"L\n\034xclPerfMonGetTrace"
  "Count_call\022\013\n\003ack\030\001 \001(\010\022\020\n\010slotname\030\002 \001("
  "\t\022\r\n\005accel\030\003 \001(\010\"9\n xclPerfMonGetTraceCo"
  "unt_response\022\025\n\rno_of_samples\030\001 \001(\r\"H\n\030x"
  "clPerfMonReadTrace_call\022\013\n\003ack\030\001 \001(\010\022\020\n\010"
  "slotname\030\002 \001(\t\022\r\n\005accel\030\003 \001(\010\"\345\001\n\034xclPer"
  "fMonReadTrace_response\0229\n\013output_data\030\010 "
  "\003(\0132$.xclPerfMonReadTrace_response.event"
  "s\032\211\001\n\006events\022\r\n\005awlen\030\001 \001(\r\022\r\n\005arlen\030\002 \001"
  "(\r\022\022\n\neventflags\030\003 \001(\r\022\021\n\ttimestamp\030\004 \001("
  "\r\022\026\n\016host_timestamp\030\005 \001(\004\022\020\n\010rd_bytes\030\006 "
  "\001(\r\022\020\n\010wr_bytes\030\007 \001(\r\"N\n\013ddr_mem_msg\022\014\n\004"
  "data\030\001 \002(\014\022\014\n\004size\030\002 \001(\004\022\021\n\tstrb_data\030\003 "
  "\001(\014\022\020\n\010fullsize\030\004 \001(\004\")\n\032xclGetDeviceTim"
  "estamp_call\022\013\n\003ack\030\001 \001(\010\":\n\036xclGetDevice"
  "Timestamp_response\022\030\n\020device_timestamp\030\001"
  " \002(\004\"\'\n\025xclReadBusStatus_call\022\016\n\006slot_n\030"
  "\001 \001(\005\"\244\001\n\031xclReadBusStatus_response\022\034\n\024u"
  "ncomplete_rd_cycles\030\001 \001(\004\022\034\n\024uncomplete_"
  "wr_cycles\030\002 \001(\004\022\027\n\017idle_bus_cycles\030\003 \001(\004"
  "\022\030\n\020uncomplete_rd_id\030\004 \001(\004\022\030\n\020uncomplete"
  "_wr_id\030\005 \001(\004\"6\n\030xclGetDebugMessages_call"
  "\022\013\n\003ack\030\001 \001(\010\022\r\n\005force\030\002 \001(\010\"Y\n\034xclGetDe"
  "bugMessages_response\022\024\n\014display_msgs\030\001 \001"
  "(\014\022\020\n\010log_msgs\030\002 \001(\014\022\021\n\tstop_msgs\030\003 \001(\014\""
  "F\n\020xclImportBO_call\022\024\n\014dst_filename\030\001 \001("
  "\t\022\016\n\006offset\030\002 \001(\004\022\014\n\004size\030\003 \001(\004\"#\n\024xclIm"
  "portBO_response\022\013\n\003ack\030\001 \001(\010\"p\n\016xclCopyB"
  "O_call\022\022\n\nsrc_handle\030\001 \001(\004\022\024\n\014dst_filena"
  "me\030\002 \001(\t\022\014\n\004size\030\003 \001(\004\022\022\n\nsrc_offset\030\004 \001"
  "(\004\022\022\n\ndst_offset\030\005 \001(\004\"!\n\022xclCopyBO_resp"
  "onse\022\013\n\003ack\030\001 \001(\010\"\217\001\n\023xclCreateQueue_cal"
  "l\022\r\n\005write\030\001 \001(\010\022\014\n\004type\030\002 \001(\r\022\r\n\005state\030"
  "\003 \001(\r\022\r\n\005route\030\004 \001(\r\022\014\n\004flow\030\005 \001(\004\022\r\n\005qs"
  "ize\030\006 \001(\r\022\021\n\tdesc_size\030\007 \001(\r\022\r\n\005flags\030\010 "
  "\001(\004\"+\n\027xclCreateQueue_response\022\020\n\010q_hand"
  "le\030\001 \001(\004\"p\n\022xclWriteQueue_call\022\020\n\010q_hand"
  "le\030\001 \001(\004\022\013\n\003src\030\002 \001(\014\022\014\n\004size\030\003 \001(\004\022\013\n\003r"
  "eq\030\004 \001(\004\022\023\n\013nonblocking\030\005 \001(\010\022\013\n\003eot\030\006 \001"
  "(\010\".\n\026xclWriteQueue_response\022\024\n\014written_"
  "size\030\001 \001(\004\"p\n\021xclReadQueue_call\022\020\n\010q_han"
  "dle\030\001 \001(\004\022\014\n\004dest\030\002 \001(\014\022\014\n\004size\030\003 \001(\004\022\013\n"
  "\003req\030\004 \001(\004\022\023\n\013nonblocking\030\005 \001(\010\022\013\n\003eot\030\006"
  " \001(\010\"3\n\025xclReadQueue_response\022\014\n\004dest\030\001 "
  "\001(\014\022\014\n\004size\030\002 \001(\004\"%\n\026xclPollCompletion_c"
  "all\022\013\n\003req\030\001 \001(\004\"}\n\032xclPollCompletion_re"
  "sponse\0228\n\013fullrequest\030\003 \003(\0132#.xclPollCom"
  "pletion_response.request\032%\n\007request\022\014\n\004d"
  "est\030\001 \001(\014\022\014\n\004size\030\002 \001(\004\"(\n\024xclDestroyQue"
  "ue_call\022\020\n\010q_handle\030\001 \001(\004\"+\n\030xclDestroyQ"
  "ueue_response\022\017\n\007success\030\001 \001(\010\"\220\001\n\025xclSe"
  "tupInstance_call\022\r\n\005route\030\001 \001(\004\0221\n\005setup"
  "\030\005 \003(\0132\".xclSetupInstance_call.argflowpa"
  "ir\0325\n\013argflowpair\022\013\n\003arg\030\002 \001(\004\022\014\n\004flow\030\003"
  " \001(\004\022\013\n\003tag\030\004 \001(\t\",\n\031xclSetupInstance_re"
  "sponse\022\017\n\007success\030\001 \001(\010\"9\n%xclPerfMonRea"
  "dCounters_Streaming_call\022\020\n\010slotname\030\001 \002"
  "(\t\"\250\001\n)xclPerfMonReadCounters_Streaming_"
  "response\022\025\n\rstr_num_tranx\030\007 \001(\004\022\026\n\016str_d"
  "ata_bytes\030\010 \001(\004\022\027\n\017str_busy_cycles\030\t \001(\004"
  "\022\030\n\020str_stall_cycles\030\n \001(\004\022\031\n\021str_starve"
  "_cycles\030\013 \001(\004\"C\n\"xclPerfMonReadTrace_Str"
  "eaming_call\022\013\n\003ack\030\001 \001(\010\022\020\n\010slotname\030\002 \001"
  "(\t\"\266\001\n&xclPerfMonReadTrace_Streaming_res"
  "ponse\022C\n\013output_data\030\010 \003(\0132..xclPerfMonR"
  "eadTrace_Streaming_response.events\032G\n\006ev"
  "ents\022\022\n\neventflags\030\003 \001(\r\022\021\n\ttimestamp\030\004 "
  "\001(\r\022\026\n\016host_timestamp\030\005 \001(\004"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_rpc_5fmessages_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_rpc_5fmessages_2eproto_sccs[64] = {
  &scc_info_call_packet_info_rpc_5fmessages_2eproto.base,
  &scc_info_ddr_mem_msg_rpc_5fmessages_2eproto.base,
  &scc_info_response_packet_info_rpc_5fmessages_2eproto.base,
  &scc_info_xclAllocDeviceBuffer_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclClose_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclClose_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBO_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBO_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclCopyBufferHost2Device_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclCreateQueue_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclCreateQueue_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclDestroyQueue_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclDestroyQueue_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclFreeDeviceBuffer_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclFreeDeviceBuffer_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclGetDebugMessages_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclGetDeviceTimestamp_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclGetDeviceTimestamp_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclImportBO_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclImportBO_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto.base,
  &scc_info_xclLoadBitstream_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonGetTraceCount_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadCounters_Streaming_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadCounters_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto.base,
  &scc_info_xclPollCompletion_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclPollCompletion_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadBusStatus_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadBusStatus_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadQueue_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclReadQueue_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetEnvironment_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetupInstance_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto.base,
  &scc_info_xclSetupInstance_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteAddrKernelCtrl_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteQueue_call_rpc_5fmessages_2eproto.base,
  &scc_info_xclWriteQueue_response_rpc_5fmessages_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_rpc_5fmessages_2eproto_once;
static bool descriptor_table_rpc_5fmessages_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_rpc_5fmessages_2eproto = {
  &descriptor_table_rpc_5fmessages_2eproto_initialized, descriptor_table_protodef_rpc_5fmessages_2eproto, "rpc_messages.proto", 4867,
  &descriptor_table_rpc_5fmessages_2eproto_once, descriptor_table_rpc_5fmessages_2eproto_sccs, descriptor_table_rpc_5fmessages_2eproto_deps, 64, 0,
  schemas, file_default_instances, TableStruct_rpc_5fmessages_2eproto::offsets,
  file_level_metadata_rpc_5fmessages_2eproto, 64, file_level_enum_descriptors_rpc_5fmessages_2eproto, file_level_service_descriptors_rpc_5fmessages_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_rpc_5fmessages_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_rpc_5fmessages_2eproto), true);

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

void call_packet_info::InitAsDefaultInstance() {
}
class call_packet_info::_Internal {
 public:
  using HasBits = decltype(std::declval<call_packet_info>()._has_bits_);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_xcl_api(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

call_packet_info::call_packet_info()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:call_packet_info)
}
call_packet_info::call_packet_info(const call_packet_info& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&size_, &from.size_,
    static_cast<size_t>(reinterpret_cast<char*>(&xcl_api_) -
    reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
  // @@protoc_insertion_point(copy_constructor:call_packet_info)
}

void call_packet_info::SharedCtor() {
  ::memset(&size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&xcl_api_) -
      reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
}

call_packet_info::~call_packet_info() {
  // @@protoc_insertion_point(destructor:call_packet_info)
  SharedDtor();
}

void call_packet_info::SharedDtor() {
}

void call_packet_info::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const call_packet_info& call_packet_info::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_call_packet_info_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void call_packet_info::Clear() {
// @@protoc_insertion_point(message_clear_start:call_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&xcl_api_) -
        reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* call_packet_info::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required fixed64 size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64);
        } else goto handle_unusual;
        continue;
      // optional fixed32 xcl_api = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_xcl_api(&has_bits);
          xcl_api_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool call_packet_info::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:call_packet_info)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required fixed64 size = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (9 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional fixed32 xcl_api = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {
          _Internal::set_has_xcl_api(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &xcl_api_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:call_packet_info)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:call_packet_info)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void call_packet_info::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:call_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required fixed64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64(1, this->size(), output);
  }

  // optional fixed32 xcl_api = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32(2, this->xcl_api(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:call_packet_info)
}

::PROTOBUF_NAMESPACE_ID::uint8* call_packet_info::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:call_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required fixed64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(1, this->size(), target);
  }

  // optional fixed32 xcl_api = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(2, this->xcl_api(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:call_packet_info)
  return target;
}

size_t call_packet_info::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:call_packet_info)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required fixed64 size = 1;
  if (has_size()) {
    total_size += 1 + 8;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional fixed32 xcl_api = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void call_packet_info::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:call_packet_info)
  GOOGLE_DCHECK_NE(&from, this);
  const call_packet_info* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<call_packet_info>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:call_packet_info)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:call_packet_info)
    MergeFrom(*source);
  }
}

void call_packet_info::MergeFrom(const call_packet_info& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:call_packet_info)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000002u) {
      xcl_api_ = from.xcl_api_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void call_packet_info::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:call_packet_info)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool call_packet_info::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void call_packet_info::InternalSwap(call_packet_info* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(size_, other->size_);
  swap(xcl_api_, other->xcl_api_);
}

::PROTOBUF_NAMESPACE_ID::Metadata call_packet_info::GetMetadata() const {
  return GetMetadataStatic();
}


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

void response_packet_info::InitAsDefaultInstance() {
}
class response_packet_info::_Internal {
 public:
  using HasBits = decltype(std::declval<response_packet_info>()._has_bits_);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_xcl_api(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

response_packet_info::response_packet_info()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:response_packet_info)
}
response_packet_info::response_packet_info(const response_packet_info& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&size_, &from.size_,
    static_cast<size_t>(reinterpret_cast<char*>(&xcl_api_) -
    reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
  // @@protoc_insertion_point(copy_constructor:response_packet_info)
}

void response_packet_info::SharedCtor() {
  ::memset(&size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&xcl_api_) -
      reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
}

response_packet_info::~response_packet_info() {
  // @@protoc_insertion_point(destructor:response_packet_info)
  SharedDtor();
}

void response_packet_info::SharedDtor() {
}

void response_packet_info::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const response_packet_info& response_packet_info::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_response_packet_info_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void response_packet_info::Clear() {
// @@protoc_insertion_point(message_clear_start:response_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&xcl_api_) -
        reinterpret_cast<char*>(&size_)) + sizeof(xcl_api_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* response_packet_info::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required fixed64 size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64);
        } else goto handle_unusual;
        continue;
      // optional fixed32 xcl_api = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_xcl_api(&has_bits);
          xcl_api_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool response_packet_info::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:response_packet_info)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required fixed64 size = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (9 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional fixed32 xcl_api = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {
          _Internal::set_has_xcl_api(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &xcl_api_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:response_packet_info)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:response_packet_info)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void response_packet_info::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:response_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required fixed64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64(1, this->size(), output);
  }

  // optional fixed32 xcl_api = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32(2, this->xcl_api(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:response_packet_info)
}

::PROTOBUF_NAMESPACE_ID::uint8* response_packet_info::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:response_packet_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required fixed64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(1, this->size(), target);
  }

  // optional fixed32 xcl_api = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(2, this->xcl_api(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:response_packet_info)
  return target;
}

size_t response_packet_info::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:response_packet_info)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required fixed64 size = 1;
  if (has_size()) {
    total_size += 1 + 8;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional fixed32 xcl_api = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void response_packet_info::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:response_packet_info)
  GOOGLE_DCHECK_NE(&from, this);
  const response_packet_info* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<response_packet_info>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:response_packet_info)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:response_packet_info)
    MergeFrom(*source);
  }
}

void response_packet_info::MergeFrom(const response_packet_info& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:response_packet_info)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000002u) {
      xcl_api_ = from.xcl_api_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void response_packet_info::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:response_packet_info)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool response_packet_info::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void response_packet_info::InternalSwap(response_packet_info* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(size_, other->size_);
  swap(xcl_api_, other->xcl_api_);
}

::PROTOBUF_NAMESPACE_ID::Metadata response_packet_info::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetEnvironment_call_namevaluepair::InitAsDefaultInstance() {
}
class xclSetEnvironment_call_namevaluepair::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetEnvironment_call_namevaluepair>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclSetEnvironment_call_namevaluepair::xclSetEnvironment_call_namevaluepair()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetEnvironment_call.namevaluepair)
}
xclSetEnvironment_call_namevaluepair::xclSetEnvironment_call_namevaluepair(const xclSetEnvironment_call_namevaluepair& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_value()) {
    value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  // @@protoc_insertion_point(copy_constructor:xclSetEnvironment_call.namevaluepair)
}

void xclSetEnvironment_call_namevaluepair::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

xclSetEnvironment_call_namevaluepair::~xclSetEnvironment_call_namevaluepair() {
  // @@protoc_insertion_point(destructor:xclSetEnvironment_call.namevaluepair)
  SharedDtor();
}

void xclSetEnvironment_call_namevaluepair::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclSetEnvironment_call_namevaluepair::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetEnvironment_call_namevaluepair& xclSetEnvironment_call_namevaluepair::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetEnvironment_call_namevaluepair_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetEnvironment_call_namevaluepair::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetEnvironment_call.namevaluepair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      value_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetEnvironment_call_namevaluepair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "xclSetEnvironment_call.namevaluepair.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_value(), ptr, ctx, "xclSetEnvironment_call.namevaluepair.value");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetEnvironment_call_namevaluepair::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetEnvironment_call.namevaluepair)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclSetEnvironment_call.namevaluepair.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string value = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->value().data(), static_cast<int>(this->value().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclSetEnvironment_call.namevaluepair.value");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetEnvironment_call.namevaluepair)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetEnvironment_call.namevaluepair)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetEnvironment_call_namevaluepair::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetEnvironment_call.namevaluepair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetEnvironment_call.namevaluepair.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional string value = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), static_cast<int>(this->value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetEnvironment_call.namevaluepair.value");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->value(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetEnvironment_call.namevaluepair)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetEnvironment_call_namevaluepair::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetEnvironment_call.namevaluepair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetEnvironment_call.namevaluepair.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional string value = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), static_cast<int>(this->value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetEnvironment_call.namevaluepair.value");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->value(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetEnvironment_call.namevaluepair)
  return target;
}

size_t xclSetEnvironment_call_namevaluepair::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetEnvironment_call.namevaluepair)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string value = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->value());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetEnvironment_call_namevaluepair::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetEnvironment_call.namevaluepair)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetEnvironment_call_namevaluepair* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetEnvironment_call_namevaluepair>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetEnvironment_call.namevaluepair)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetEnvironment_call.namevaluepair)
    MergeFrom(*source);
  }
}

void xclSetEnvironment_call_namevaluepair::MergeFrom(const xclSetEnvironment_call_namevaluepair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetEnvironment_call.namevaluepair)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
    }
  }
}

void xclSetEnvironment_call_namevaluepair::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetEnvironment_call.namevaluepair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetEnvironment_call_namevaluepair::InternalSwap(xclSetEnvironment_call_namevaluepair* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetEnvironment_call_namevaluepair::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetEnvironment_call::InitAsDefaultInstance() {
}
class xclSetEnvironment_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetEnvironment_call>()._has_bits_);
};

xclSetEnvironment_call::xclSetEnvironment_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetEnvironment_call)
}
xclSetEnvironment_call::xclSetEnvironment_call(const xclSetEnvironment_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      environment_(from.environment_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:xclSetEnvironment_call)
}

void xclSetEnvironment_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto.base);
}

xclSetEnvironment_call::~xclSetEnvironment_call() {
  // @@protoc_insertion_point(destructor:xclSetEnvironment_call)
  SharedDtor();
}

void xclSetEnvironment_call::SharedDtor() {
}

void xclSetEnvironment_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetEnvironment_call& xclSetEnvironment_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetEnvironment_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetEnvironment_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetEnvironment_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  environment_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetEnvironment_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_environment(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetEnvironment_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetEnvironment_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_environment()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetEnvironment_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetEnvironment_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetEnvironment_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetEnvironment_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->environment_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3,
      this->environment(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetEnvironment_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetEnvironment_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetEnvironment_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->environment_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->environment(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetEnvironment_call)
  return target;
}

size_t xclSetEnvironment_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetEnvironment_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclSetEnvironment_call.namevaluepair environment = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->environment_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->environment(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetEnvironment_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetEnvironment_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetEnvironment_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetEnvironment_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetEnvironment_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetEnvironment_call)
    MergeFrom(*source);
  }
}

void xclSetEnvironment_call::MergeFrom(const xclSetEnvironment_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetEnvironment_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  environment_.MergeFrom(from.environment_);
}

void xclSetEnvironment_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetEnvironment_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetEnvironment_call::InternalSwap(xclSetEnvironment_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&environment_)->InternalSwap(CastToBase(&other->environment_));
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetEnvironment_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetEnvironment_response::InitAsDefaultInstance() {
}
class xclSetEnvironment_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetEnvironment_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclSetEnvironment_response::xclSetEnvironment_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetEnvironment_response)
}
xclSetEnvironment_response::xclSetEnvironment_response(const xclSetEnvironment_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclSetEnvironment_response)
}

void xclSetEnvironment_response::SharedCtor() {
  ack_ = false;
}

xclSetEnvironment_response::~xclSetEnvironment_response() {
  // @@protoc_insertion_point(destructor:xclSetEnvironment_response)
  SharedDtor();
}

void xclSetEnvironment_response::SharedDtor() {
}

void xclSetEnvironment_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetEnvironment_response& xclSetEnvironment_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetEnvironment_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetEnvironment_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetEnvironment_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetEnvironment_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetEnvironment_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetEnvironment_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetEnvironment_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetEnvironment_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetEnvironment_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetEnvironment_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetEnvironment_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetEnvironment_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetEnvironment_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetEnvironment_response)
  return target;
}

size_t xclSetEnvironment_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetEnvironment_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool ack = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetEnvironment_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetEnvironment_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetEnvironment_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetEnvironment_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetEnvironment_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetEnvironment_response)
    MergeFrom(*source);
  }
}

void xclSetEnvironment_response::MergeFrom(const xclSetEnvironment_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetEnvironment_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclSetEnvironment_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetEnvironment_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetEnvironment_response::InternalSwap(xclSetEnvironment_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetEnvironment_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclLoadBitstream_call_ddrbank::InitAsDefaultInstance() {
}
class xclLoadBitstream_call_ddrbank::_Internal {
 public:
  using HasBits = decltype(std::declval<xclLoadBitstream_call_ddrbank>()._has_bits_);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclLoadBitstream_call_ddrbank::xclLoadBitstream_call_ddrbank()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclLoadBitstream_call.ddrbank)
}
xclLoadBitstream_call_ddrbank::xclLoadBitstream_call_ddrbank(const xclLoadBitstream_call_ddrbank& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:xclLoadBitstream_call.ddrbank)
}

void xclLoadBitstream_call_ddrbank::SharedCtor() {
  size_ = PROTOBUF_ULONGLONG(0);
}

xclLoadBitstream_call_ddrbank::~xclLoadBitstream_call_ddrbank() {
  // @@protoc_insertion_point(destructor:xclLoadBitstream_call.ddrbank)
  SharedDtor();
}

void xclLoadBitstream_call_ddrbank::SharedDtor() {
}

void xclLoadBitstream_call_ddrbank::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclLoadBitstream_call_ddrbank& xclLoadBitstream_call_ddrbank::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclLoadBitstream_call_ddrbank_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclLoadBitstream_call_ddrbank::Clear() {
// @@protoc_insertion_point(message_clear_start:xclLoadBitstream_call.ddrbank)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclLoadBitstream_call_ddrbank::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 size = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclLoadBitstream_call_ddrbank::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclLoadBitstream_call.ddrbank)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 size = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclLoadBitstream_call.ddrbank)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclLoadBitstream_call.ddrbank)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclLoadBitstream_call_ddrbank::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclLoadBitstream_call.ddrbank)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 size = 7;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(7, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclLoadBitstream_call.ddrbank)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclLoadBitstream_call_ddrbank::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclLoadBitstream_call.ddrbank)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 size = 7;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclLoadBitstream_call.ddrbank)
  return target;
}

size_t xclLoadBitstream_call_ddrbank::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclLoadBitstream_call.ddrbank)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 size = 7;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclLoadBitstream_call_ddrbank::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclLoadBitstream_call.ddrbank)
  GOOGLE_DCHECK_NE(&from, this);
  const xclLoadBitstream_call_ddrbank* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclLoadBitstream_call_ddrbank>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclLoadBitstream_call.ddrbank)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclLoadBitstream_call.ddrbank)
    MergeFrom(*source);
  }
}

void xclLoadBitstream_call_ddrbank::MergeFrom(const xclLoadBitstream_call_ddrbank& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclLoadBitstream_call.ddrbank)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_size()) {
    set_size(from.size());
  }
}

void xclLoadBitstream_call_ddrbank::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclLoadBitstream_call.ddrbank)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclLoadBitstream_call_ddrbank::InternalSwap(xclLoadBitstream_call_ddrbank* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclLoadBitstream_call_ddrbank::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclLoadBitstream_call::InitAsDefaultInstance() {
}
class xclLoadBitstream_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclLoadBitstream_call>()._has_bits_);
  static void set_has_xmlfile(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_dlopenfilename(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_devicename(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_devicedirectory(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_binarydirectory(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_verbose(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclLoadBitstream_call::xclLoadBitstream_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclLoadBitstream_call)
}
xclLoadBitstream_call::xclLoadBitstream_call(const xclLoadBitstream_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      ddrbanks_(from.ddrbanks_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  xmlfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_xmlfile()) {
    xmlfile_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xmlfile_);
  }
  dlopenfilename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dlopenfilename()) {
    dlopenfilename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dlopenfilename_);
  }
  devicename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_devicename()) {
    devicename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.devicename_);
  }
  devicedirectory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_devicedirectory()) {
    devicedirectory_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.devicedirectory_);
  }
  binarydirectory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_binarydirectory()) {
    binarydirectory_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binarydirectory_);
  }
  verbose_ = from.verbose_;
  // @@protoc_insertion_point(copy_constructor:xclLoadBitstream_call)
}

void xclLoadBitstream_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto.base);
  xmlfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  dlopenfilename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  devicename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  devicedirectory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  binarydirectory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  verbose_ = false;
}

xclLoadBitstream_call::~xclLoadBitstream_call() {
  // @@protoc_insertion_point(destructor:xclLoadBitstream_call)
  SharedDtor();
}

void xclLoadBitstream_call::SharedDtor() {
  xmlfile_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  dlopenfilename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  devicename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  devicedirectory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  binarydirectory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclLoadBitstream_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclLoadBitstream_call& xclLoadBitstream_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclLoadBitstream_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclLoadBitstream_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclLoadBitstream_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ddrbanks_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      xmlfile_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      dlopenfilename_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      devicename_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000008u) {
      devicedirectory_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000010u) {
      binarydirectory_.ClearNonDefaultToEmptyNoArena();
    }
  }
  verbose_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclLoadBitstream_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bytes xmlfile = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_xmlfile(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes dlopenfilename = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dlopenfilename(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes devicename = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_devicename(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes devicedirectory = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_devicedirectory(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes binarydirectory = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_binarydirectory(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bool verbose = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_verbose(&has_bits);
          verbose_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_ddrbanks(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclLoadBitstream_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclLoadBitstream_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes xmlfile = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_xmlfile()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes dlopenfilename = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dlopenfilename()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes devicename = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_devicename()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes devicedirectory = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_devicedirectory()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes binarydirectory = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_binarydirectory()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bool verbose = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_verbose(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &verbose_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_ddrbanks()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclLoadBitstream_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclLoadBitstream_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclLoadBitstream_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclLoadBitstream_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xmlfile = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->xmlfile(), output);
  }

  // required bytes dlopenfilename = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->dlopenfilename(), output);
  }

  // required bytes devicename = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->devicename(), output);
  }

  // required bytes devicedirectory = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->devicedirectory(), output);
  }

  // required bytes binarydirectory = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      5, this->binarydirectory(), output);
  }

  // required bool verbose = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->verbose(), output);
  }

  // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->ddrbanks_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      8,
      this->ddrbanks(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclLoadBitstream_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclLoadBitstream_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclLoadBitstream_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xmlfile = 1;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        1, this->xmlfile(), target);
  }

  // required bytes dlopenfilename = 2;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->dlopenfilename(), target);
  }

  // required bytes devicename = 3;
  if (cached_has_bits & 0x00000004u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        3, this->devicename(), target);
  }

  // required bytes devicedirectory = 4;
  if (cached_has_bits & 0x00000008u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->devicedirectory(), target);
  }

  // required bytes binarydirectory = 5;
  if (cached_has_bits & 0x00000010u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        5, this->binarydirectory(), target);
  }

  // required bool verbose = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->verbose(), target);
  }

  // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->ddrbanks_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, this->ddrbanks(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclLoadBitstream_call)
  return target;
}

size_t xclLoadBitstream_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclLoadBitstream_call)
  size_t total_size = 0;

  if (has_xmlfile()) {
    // required bytes xmlfile = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xmlfile());
  }

  if (has_dlopenfilename()) {
    // required bytes dlopenfilename = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dlopenfilename());
  }

  if (has_devicename()) {
    // required bytes devicename = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->devicename());
  }

  if (has_devicedirectory()) {
    // required bytes devicedirectory = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->devicedirectory());
  }

  if (has_binarydirectory()) {
    // required bytes binarydirectory = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->binarydirectory());
  }

  if (has_verbose()) {
    // required bool verbose = 6;
    total_size += 1 + 1;
  }

  return total_size;
}
size_t xclLoadBitstream_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclLoadBitstream_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
    // required bytes xmlfile = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xmlfile());

    // required bytes dlopenfilename = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dlopenfilename());

    // required bytes devicename = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->devicename());

    // required bytes devicedirectory = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->devicedirectory());

    // required bytes binarydirectory = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->binarydirectory());

    // required bool verbose = 6;
    total_size += 1 + 1;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclLoadBitstream_call.ddrbank ddrbanks = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->ddrbanks_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->ddrbanks(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclLoadBitstream_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclLoadBitstream_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclLoadBitstream_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclLoadBitstream_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclLoadBitstream_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclLoadBitstream_call)
    MergeFrom(*source);
  }
}

void xclLoadBitstream_call::MergeFrom(const xclLoadBitstream_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclLoadBitstream_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  ddrbanks_.MergeFrom(from.ddrbanks_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      xmlfile_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xmlfile_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      dlopenfilename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dlopenfilename_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      devicename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.devicename_);
    }
    if (cached_has_bits & 0x00000008u) {
      _has_bits_[0] |= 0x00000008u;
      devicedirectory_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.devicedirectory_);
    }
    if (cached_has_bits & 0x00000010u) {
      _has_bits_[0] |= 0x00000010u;
      binarydirectory_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binarydirectory_);
    }
    if (cached_has_bits & 0x00000020u) {
      verbose_ = from.verbose_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclLoadBitstream_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclLoadBitstream_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclLoadBitstream_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
  return true;
}

void xclLoadBitstream_call::InternalSwap(xclLoadBitstream_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&ddrbanks_)->InternalSwap(CastToBase(&other->ddrbanks_));
  xmlfile_.Swap(&other->xmlfile_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  dlopenfilename_.Swap(&other->dlopenfilename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  devicename_.Swap(&other->devicename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  devicedirectory_.Swap(&other->devicedirectory_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  binarydirectory_.Swap(&other->binarydirectory_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(verbose_, other->verbose_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclLoadBitstream_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclLoadBitstream_response::InitAsDefaultInstance() {
}
class xclLoadBitstream_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclLoadBitstream_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclLoadBitstream_response::xclLoadBitstream_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclLoadBitstream_response)
}
xclLoadBitstream_response::xclLoadBitstream_response(const xclLoadBitstream_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclLoadBitstream_response)
}

void xclLoadBitstream_response::SharedCtor() {
  ack_ = false;
}

xclLoadBitstream_response::~xclLoadBitstream_response() {
  // @@protoc_insertion_point(destructor:xclLoadBitstream_response)
  SharedDtor();
}

void xclLoadBitstream_response::SharedDtor() {
}

void xclLoadBitstream_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclLoadBitstream_response& xclLoadBitstream_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclLoadBitstream_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclLoadBitstream_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclLoadBitstream_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclLoadBitstream_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclLoadBitstream_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclLoadBitstream_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclLoadBitstream_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclLoadBitstream_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclLoadBitstream_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclLoadBitstream_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclLoadBitstream_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclLoadBitstream_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclLoadBitstream_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclLoadBitstream_response)
  return target;
}

size_t xclLoadBitstream_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclLoadBitstream_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool ack = 1;
  if (has_ack()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclLoadBitstream_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclLoadBitstream_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclLoadBitstream_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclLoadBitstream_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclLoadBitstream_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclLoadBitstream_response)
    MergeFrom(*source);
  }
}

void xclLoadBitstream_response::MergeFrom(const xclLoadBitstream_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclLoadBitstream_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclLoadBitstream_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclLoadBitstream_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclLoadBitstream_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclLoadBitstream_response::InternalSwap(xclLoadBitstream_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclLoadBitstream_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclAllocDeviceBuffer_call::InitAsDefaultInstance() {
}
class xclAllocDeviceBuffer_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclAllocDeviceBuffer_call>()._has_bits_);
  static void set_has_ddraddress(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_peertopeer(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclAllocDeviceBuffer_call::xclAllocDeviceBuffer_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclAllocDeviceBuffer_call)
}
xclAllocDeviceBuffer_call::xclAllocDeviceBuffer_call(const xclAllocDeviceBuffer_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ddraddress_, &from.ddraddress_,
    static_cast<size_t>(reinterpret_cast<char*>(&peertopeer_) -
    reinterpret_cast<char*>(&ddraddress_)) + sizeof(peertopeer_));
  // @@protoc_insertion_point(copy_constructor:xclAllocDeviceBuffer_call)
}

void xclAllocDeviceBuffer_call::SharedCtor() {
  ::memset(&ddraddress_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&peertopeer_) -
      reinterpret_cast<char*>(&ddraddress_)) + sizeof(peertopeer_));
}

xclAllocDeviceBuffer_call::~xclAllocDeviceBuffer_call() {
  // @@protoc_insertion_point(destructor:xclAllocDeviceBuffer_call)
  SharedDtor();
}

void xclAllocDeviceBuffer_call::SharedDtor() {
}

void xclAllocDeviceBuffer_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclAllocDeviceBuffer_call& xclAllocDeviceBuffer_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclAllocDeviceBuffer_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclAllocDeviceBuffer_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclAllocDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&ddraddress_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&peertopeer_) -
        reinterpret_cast<char*>(&ddraddress_)) + sizeof(peertopeer_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclAllocDeviceBuffer_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 ddraddress = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ddraddress(&has_bits);
          ddraddress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool peertopeer = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_peertopeer(&has_bits);
          peertopeer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclAllocDeviceBuffer_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclAllocDeviceBuffer_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 ddraddress = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ddraddress(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &ddraddress_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 size = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool peertopeer = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_peertopeer(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &peertopeer_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclAllocDeviceBuffer_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclAllocDeviceBuffer_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclAllocDeviceBuffer_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclAllocDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 ddraddress = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->ddraddress(), output);
  }

  // required uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->size(), output);
  }

  // optional bool peertopeer = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->peertopeer(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclAllocDeviceBuffer_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclAllocDeviceBuffer_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclAllocDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 ddraddress = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->ddraddress(), target);
  }

  // required uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->size(), target);
  }

  // optional bool peertopeer = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->peertopeer(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclAllocDeviceBuffer_call)
  return target;
}

size_t xclAllocDeviceBuffer_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclAllocDeviceBuffer_call)
  size_t total_size = 0;

  if (has_ddraddress()) {
    // required uint64 ddraddress = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->ddraddress());
  }

  if (has_size()) {
    // required uint64 size = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }

  return total_size;
}
size_t xclAllocDeviceBuffer_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclAllocDeviceBuffer_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required uint64 ddraddress = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->ddraddress());

    // required uint64 size = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool peertopeer = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000004u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclAllocDeviceBuffer_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclAllocDeviceBuffer_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclAllocDeviceBuffer_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclAllocDeviceBuffer_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclAllocDeviceBuffer_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclAllocDeviceBuffer_call)
    MergeFrom(*source);
  }
}

void xclAllocDeviceBuffer_call::MergeFrom(const xclAllocDeviceBuffer_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclAllocDeviceBuffer_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ddraddress_ = from.ddraddress_;
    }
    if (cached_has_bits & 0x00000002u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000004u) {
      peertopeer_ = from.peertopeer_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclAllocDeviceBuffer_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclAllocDeviceBuffer_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclAllocDeviceBuffer_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  return true;
}

void xclAllocDeviceBuffer_call::InternalSwap(xclAllocDeviceBuffer_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ddraddress_, other->ddraddress_);
  swap(size_, other->size_);
  swap(peertopeer_, other->peertopeer_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclAllocDeviceBuffer_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclAllocDeviceBuffer_response::InitAsDefaultInstance() {
}
class xclAllocDeviceBuffer_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclAllocDeviceBuffer_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclAllocDeviceBuffer_response::xclAllocDeviceBuffer_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclAllocDeviceBuffer_response)
}
xclAllocDeviceBuffer_response::xclAllocDeviceBuffer_response(const xclAllocDeviceBuffer_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_filename()) {
    filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.filename_);
  }
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclAllocDeviceBuffer_response)
}

void xclAllocDeviceBuffer_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto.base);
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ack_ = false;
}

xclAllocDeviceBuffer_response::~xclAllocDeviceBuffer_response() {
  // @@protoc_insertion_point(destructor:xclAllocDeviceBuffer_response)
  SharedDtor();
}

void xclAllocDeviceBuffer_response::SharedDtor() {
  filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclAllocDeviceBuffer_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclAllocDeviceBuffer_response& xclAllocDeviceBuffer_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclAllocDeviceBuffer_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclAllocDeviceBuffer_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclAllocDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    filename_.ClearNonDefaultToEmptyNoArena();
  }
  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclAllocDeviceBuffer_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string filename = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_filename(), ptr, ctx, "xclAllocDeviceBuffer_response.filename");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclAllocDeviceBuffer_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclAllocDeviceBuffer_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string filename = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_filename()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->filename().data(), static_cast<int>(this->filename().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclAllocDeviceBuffer_response.filename");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclAllocDeviceBuffer_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclAllocDeviceBuffer_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclAllocDeviceBuffer_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclAllocDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  // optional string filename = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->filename().data(), static_cast<int>(this->filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclAllocDeviceBuffer_response.filename");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->filename(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclAllocDeviceBuffer_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclAllocDeviceBuffer_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclAllocDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  // optional string filename = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->filename().data(), static_cast<int>(this->filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclAllocDeviceBuffer_response.filename");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->filename(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclAllocDeviceBuffer_response)
  return target;
}

size_t xclAllocDeviceBuffer_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclAllocDeviceBuffer_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool ack = 1;
  if (has_ack()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string filename = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->filename());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclAllocDeviceBuffer_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclAllocDeviceBuffer_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclAllocDeviceBuffer_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclAllocDeviceBuffer_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclAllocDeviceBuffer_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclAllocDeviceBuffer_response)
    MergeFrom(*source);
  }
}

void xclAllocDeviceBuffer_response::MergeFrom(const xclAllocDeviceBuffer_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclAllocDeviceBuffer_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.filename_);
    }
    if (cached_has_bits & 0x00000002u) {
      ack_ = from.ack_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclAllocDeviceBuffer_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclAllocDeviceBuffer_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclAllocDeviceBuffer_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
  return true;
}

void xclAllocDeviceBuffer_response::InternalSwap(xclAllocDeviceBuffer_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  filename_.Swap(&other->filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclAllocDeviceBuffer_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclFreeDeviceBuffer_call::InitAsDefaultInstance() {
}
class xclFreeDeviceBuffer_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclFreeDeviceBuffer_call>()._has_bits_);
  static void set_has_ddraddress(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclFreeDeviceBuffer_call::xclFreeDeviceBuffer_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclFreeDeviceBuffer_call)
}
xclFreeDeviceBuffer_call::xclFreeDeviceBuffer_call(const xclFreeDeviceBuffer_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ddraddress_ = from.ddraddress_;
  // @@protoc_insertion_point(copy_constructor:xclFreeDeviceBuffer_call)
}

void xclFreeDeviceBuffer_call::SharedCtor() {
  ddraddress_ = PROTOBUF_ULONGLONG(0);
}

xclFreeDeviceBuffer_call::~xclFreeDeviceBuffer_call() {
  // @@protoc_insertion_point(destructor:xclFreeDeviceBuffer_call)
  SharedDtor();
}

void xclFreeDeviceBuffer_call::SharedDtor() {
}

void xclFreeDeviceBuffer_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclFreeDeviceBuffer_call& xclFreeDeviceBuffer_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclFreeDeviceBuffer_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclFreeDeviceBuffer_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclFreeDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ddraddress_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclFreeDeviceBuffer_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 ddraddress = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ddraddress(&has_bits);
          ddraddress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclFreeDeviceBuffer_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclFreeDeviceBuffer_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 ddraddress = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ddraddress(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &ddraddress_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclFreeDeviceBuffer_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclFreeDeviceBuffer_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclFreeDeviceBuffer_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclFreeDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 ddraddress = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->ddraddress(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclFreeDeviceBuffer_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclFreeDeviceBuffer_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclFreeDeviceBuffer_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 ddraddress = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->ddraddress(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclFreeDeviceBuffer_call)
  return target;
}

size_t xclFreeDeviceBuffer_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclFreeDeviceBuffer_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required uint64 ddraddress = 1;
  if (has_ddraddress()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->ddraddress());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclFreeDeviceBuffer_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclFreeDeviceBuffer_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclFreeDeviceBuffer_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclFreeDeviceBuffer_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclFreeDeviceBuffer_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclFreeDeviceBuffer_call)
    MergeFrom(*source);
  }
}

void xclFreeDeviceBuffer_call::MergeFrom(const xclFreeDeviceBuffer_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclFreeDeviceBuffer_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ddraddress()) {
    set_ddraddress(from.ddraddress());
  }
}

void xclFreeDeviceBuffer_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclFreeDeviceBuffer_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclFreeDeviceBuffer_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclFreeDeviceBuffer_call::InternalSwap(xclFreeDeviceBuffer_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ddraddress_, other->ddraddress_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclFreeDeviceBuffer_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclFreeDeviceBuffer_response::InitAsDefaultInstance() {
}
class xclFreeDeviceBuffer_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclFreeDeviceBuffer_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclFreeDeviceBuffer_response::xclFreeDeviceBuffer_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclFreeDeviceBuffer_response)
}
xclFreeDeviceBuffer_response::xclFreeDeviceBuffer_response(const xclFreeDeviceBuffer_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclFreeDeviceBuffer_response)
}

void xclFreeDeviceBuffer_response::SharedCtor() {
  ack_ = false;
}

xclFreeDeviceBuffer_response::~xclFreeDeviceBuffer_response() {
  // @@protoc_insertion_point(destructor:xclFreeDeviceBuffer_response)
  SharedDtor();
}

void xclFreeDeviceBuffer_response::SharedDtor() {
}

void xclFreeDeviceBuffer_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclFreeDeviceBuffer_response& xclFreeDeviceBuffer_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclFreeDeviceBuffer_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclFreeDeviceBuffer_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclFreeDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclFreeDeviceBuffer_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclFreeDeviceBuffer_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclFreeDeviceBuffer_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclFreeDeviceBuffer_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclFreeDeviceBuffer_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclFreeDeviceBuffer_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclFreeDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclFreeDeviceBuffer_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclFreeDeviceBuffer_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclFreeDeviceBuffer_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclFreeDeviceBuffer_response)
  return target;
}

size_t xclFreeDeviceBuffer_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclFreeDeviceBuffer_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool ack = 1;
  if (has_ack()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclFreeDeviceBuffer_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclFreeDeviceBuffer_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclFreeDeviceBuffer_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclFreeDeviceBuffer_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclFreeDeviceBuffer_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclFreeDeviceBuffer_response)
    MergeFrom(*source);
  }
}

void xclFreeDeviceBuffer_response::MergeFrom(const xclFreeDeviceBuffer_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclFreeDeviceBuffer_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclFreeDeviceBuffer_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclFreeDeviceBuffer_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclFreeDeviceBuffer_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclFreeDeviceBuffer_response::InternalSwap(xclFreeDeviceBuffer_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclFreeDeviceBuffer_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclClose_call::InitAsDefaultInstance() {
}
class xclClose_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclClose_call>()._has_bits_);
  static void set_has_xcldevicehandle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_closeall(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclClose_call::xclClose_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclClose_call)
}
xclClose_call::xclClose_call(const xclClose_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_xcldevicehandle()) {
    xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
  }
  closeall_ = from.closeall_;
  // @@protoc_insertion_point(copy_constructor:xclClose_call)
}

void xclClose_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclClose_call_rpc_5fmessages_2eproto.base);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  closeall_ = false;
}

xclClose_call::~xclClose_call() {
  // @@protoc_insertion_point(destructor:xclClose_call)
  SharedDtor();
}

void xclClose_call::SharedDtor() {
  xcldevicehandle_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclClose_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclClose_call& xclClose_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclClose_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclClose_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclClose_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    xcldevicehandle_.ClearNonDefaultToEmptyNoArena();
  }
  closeall_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclClose_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bytes xclDeviceHandle = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_xcldevicehandle(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool closeall = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_closeall(&has_bits);
          closeall_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclClose_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclClose_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes xclDeviceHandle = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_xcldevicehandle()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool closeall = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_closeall(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &closeall_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclClose_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclClose_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclClose_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclClose_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->xcldevicehandle(), output);
  }

  // optional bool closeall = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->closeall(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclClose_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclClose_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclClose_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->xcldevicehandle(), target);
  }

  // optional bool closeall = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->closeall(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclClose_call)
  return target;
}

size_t xclClose_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclClose_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes xclDeviceHandle = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->xcldevicehandle());
    }

    // optional bool closeall = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclClose_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclClose_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclClose_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclClose_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclClose_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclClose_call)
    MergeFrom(*source);
  }
}

void xclClose_call::MergeFrom(const xclClose_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclClose_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
    }
    if (cached_has_bits & 0x00000002u) {
      closeall_ = from.closeall_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclClose_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclClose_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclClose_call::InternalSwap(xclClose_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  xcldevicehandle_.Swap(&other->xcldevicehandle_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(closeall_, other->closeall_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclClose_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclClose_response::InitAsDefaultInstance() {
}
class xclClose_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclClose_response>()._has_bits_);
  static void set_has_valid(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclClose_response::xclClose_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclClose_response)
}
xclClose_response::xclClose_response(const xclClose_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  valid_ = from.valid_;
  // @@protoc_insertion_point(copy_constructor:xclClose_response)
}

void xclClose_response::SharedCtor() {
  valid_ = false;
}

xclClose_response::~xclClose_response() {
  // @@protoc_insertion_point(destructor:xclClose_response)
  SharedDtor();
}

void xclClose_response::SharedDtor() {
}

void xclClose_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclClose_response& xclClose_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclClose_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclClose_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclClose_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  valid_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclClose_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool valid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_valid(&has_bits);
          valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclClose_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclClose_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool valid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_valid(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &valid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclClose_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclClose_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclClose_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclClose_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->valid(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclClose_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclClose_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclClose_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->valid(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclClose_response)
  return target;
}

size_t xclClose_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclClose_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool valid = 1;
  if (has_valid()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclClose_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclClose_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclClose_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclClose_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclClose_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclClose_response)
    MergeFrom(*source);
  }
}

void xclClose_response::MergeFrom(const xclClose_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclClose_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_valid()) {
    set_valid(from.valid());
  }
}

void xclClose_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclClose_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclClose_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclClose_response::InternalSwap(xclClose_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(valid_, other->valid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclClose_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBufferHost2Device_call::InitAsDefaultInstance() {
}
class xclCopyBufferHost2Device_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBufferHost2Device_call>()._has_bits_);
  static void set_has_xcldevicehandle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_src(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_seek(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_space(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclCopyBufferHost2Device_call::xclCopyBufferHost2Device_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBufferHost2Device_call)
}
xclCopyBufferHost2Device_call::xclCopyBufferHost2Device_call(const xclCopyBufferHost2Device_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_xcldevicehandle()) {
    xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
  }
  src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_src()) {
    src_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.src_);
  }
  ::memcpy(&dest_, &from.dest_,
    static_cast<size_t>(reinterpret_cast<char*>(&space_) -
    reinterpret_cast<char*>(&dest_)) + sizeof(space_));
  // @@protoc_insertion_point(copy_constructor:xclCopyBufferHost2Device_call)
}

void xclCopyBufferHost2Device_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto.base);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&dest_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&space_) -
      reinterpret_cast<char*>(&dest_)) + sizeof(space_));
}

xclCopyBufferHost2Device_call::~xclCopyBufferHost2Device_call() {
  // @@protoc_insertion_point(destructor:xclCopyBufferHost2Device_call)
  SharedDtor();
}

void xclCopyBufferHost2Device_call::SharedDtor() {
  xcldevicehandle_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  src_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclCopyBufferHost2Device_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBufferHost2Device_call& xclCopyBufferHost2Device_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBufferHost2Device_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBufferHost2Device_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBufferHost2Device_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      xcldevicehandle_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      src_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x0000003cu) {
    ::memset(&dest_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&space_) -
        reinterpret_cast<char*>(&dest_)) + sizeof(space_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBufferHost2Device_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bytes xclDeviceHandle = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_xcldevicehandle(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 dest = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_dest(&has_bits);
          dest_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes src = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_src(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 size = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 seek = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_seek(&has_bits);
          seek_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 space = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_space(&has_bits);
          space_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBufferHost2Device_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBufferHost2Device_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes xclDeviceHandle = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_xcldevicehandle()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 dest = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_dest(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &dest_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes src = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_src()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 size = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 seek = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_seek(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &seek_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 space = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_space(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &space_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBufferHost2Device_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBufferHost2Device_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBufferHost2Device_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBufferHost2Device_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->xcldevicehandle(), output);
  }

  // required uint64 dest = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->dest(), output);
  }

  // required bytes src = 4;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->src(), output);
  }

  // required uint64 size = 5;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->size(), output);
  }

  // required uint64 seek = 6;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(6, this->seek(), output);
  }

  // optional uint32 space = 7;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(7, this->space(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBufferHost2Device_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBufferHost2Device_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBufferHost2Device_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->xcldevicehandle(), target);
  }

  // required uint64 dest = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->dest(), target);
  }

  // required bytes src = 4;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->src(), target);
  }

  // required uint64 size = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->size(), target);
  }

  // required uint64 seek = 6;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->seek(), target);
  }

  // optional uint32 space = 7;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->space(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBufferHost2Device_call)
  return target;
}

size_t xclCopyBufferHost2Device_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclCopyBufferHost2Device_call)
  size_t total_size = 0;

  if (has_xcldevicehandle()) {
    // required bytes xclDeviceHandle = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xcldevicehandle());
  }

  if (has_src()) {
    // required bytes src = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->src());
  }

  if (has_dest()) {
    // required uint64 dest = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->dest());
  }

  if (has_size()) {
    // required uint64 size = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }

  if (has_seek()) {
    // required uint64 seek = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->seek());
  }

  return total_size;
}
size_t xclCopyBufferHost2Device_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBufferHost2Device_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required bytes xclDeviceHandle = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xcldevicehandle());

    // required bytes src = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->src());

    // required uint64 dest = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->dest());

    // required uint64 size = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());

    // required uint64 seek = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->seek());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 space = 7;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000020u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->space());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBufferHost2Device_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBufferHost2Device_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBufferHost2Device_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBufferHost2Device_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBufferHost2Device_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBufferHost2Device_call)
    MergeFrom(*source);
  }
}

void xclCopyBufferHost2Device_call::MergeFrom(const xclCopyBufferHost2Device_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBufferHost2Device_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      src_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.src_);
    }
    if (cached_has_bits & 0x00000004u) {
      dest_ = from.dest_;
    }
    if (cached_has_bits & 0x00000008u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000010u) {
      seek_ = from.seek_;
    }
    if (cached_has_bits & 0x00000020u) {
      space_ = from.space_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclCopyBufferHost2Device_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBufferHost2Device_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclCopyBufferHost2Device_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
  return true;
}

void xclCopyBufferHost2Device_call::InternalSwap(xclCopyBufferHost2Device_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  xcldevicehandle_.Swap(&other->xcldevicehandle_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  src_.Swap(&other->src_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(dest_, other->dest_);
  swap(size_, other->size_);
  swap(seek_, other->seek_);
  swap(space_, other->space_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBufferHost2Device_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBufferHost2Device_response::InitAsDefaultInstance() {
}
class xclCopyBufferHost2Device_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBufferHost2Device_response>()._has_bits_);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclCopyBufferHost2Device_response::xclCopyBufferHost2Device_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBufferHost2Device_response)
}
xclCopyBufferHost2Device_response::xclCopyBufferHost2Device_response(const xclCopyBufferHost2Device_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:xclCopyBufferHost2Device_response)
}

void xclCopyBufferHost2Device_response::SharedCtor() {
  size_ = PROTOBUF_ULONGLONG(0);
}

xclCopyBufferHost2Device_response::~xclCopyBufferHost2Device_response() {
  // @@protoc_insertion_point(destructor:xclCopyBufferHost2Device_response)
  SharedDtor();
}

void xclCopyBufferHost2Device_response::SharedDtor() {
}

void xclCopyBufferHost2Device_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBufferHost2Device_response& xclCopyBufferHost2Device_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBufferHost2Device_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBufferHost2Device_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBufferHost2Device_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBufferHost2Device_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBufferHost2Device_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBufferHost2Device_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 size = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBufferHost2Device_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBufferHost2Device_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBufferHost2Device_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBufferHost2Device_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBufferHost2Device_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBufferHost2Device_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBufferHost2Device_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBufferHost2Device_response)
  return target;
}

size_t xclCopyBufferHost2Device_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBufferHost2Device_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required uint64 size = 1;
  if (has_size()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBufferHost2Device_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBufferHost2Device_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBufferHost2Device_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBufferHost2Device_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBufferHost2Device_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBufferHost2Device_response)
    MergeFrom(*source);
  }
}

void xclCopyBufferHost2Device_response::MergeFrom(const xclCopyBufferHost2Device_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBufferHost2Device_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_size()) {
    set_size(from.size());
  }
}

void xclCopyBufferHost2Device_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBufferHost2Device_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclCopyBufferHost2Device_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclCopyBufferHost2Device_response::InternalSwap(xclCopyBufferHost2Device_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBufferHost2Device_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBufferDevice2Host_call::InitAsDefaultInstance() {
}
class xclCopyBufferDevice2Host_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBufferDevice2Host_call>()._has_bits_);
  static void set_has_xcldevicehandle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_src(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_skip(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_space(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclCopyBufferDevice2Host_call::xclCopyBufferDevice2Host_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBufferDevice2Host_call)
}
xclCopyBufferDevice2Host_call::xclCopyBufferDevice2Host_call(const xclCopyBufferDevice2Host_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_xcldevicehandle()) {
    xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
  }
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dest()) {
    dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
  }
  ::memcpy(&src_, &from.src_,
    static_cast<size_t>(reinterpret_cast<char*>(&space_) -
    reinterpret_cast<char*>(&src_)) + sizeof(space_));
  // @@protoc_insertion_point(copy_constructor:xclCopyBufferDevice2Host_call)
}

void xclCopyBufferDevice2Host_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto.base);
  xcldevicehandle_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&src_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&space_) -
      reinterpret_cast<char*>(&src_)) + sizeof(space_));
}

xclCopyBufferDevice2Host_call::~xclCopyBufferDevice2Host_call() {
  // @@protoc_insertion_point(destructor:xclCopyBufferDevice2Host_call)
  SharedDtor();
}

void xclCopyBufferDevice2Host_call::SharedDtor() {
  xcldevicehandle_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  dest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclCopyBufferDevice2Host_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBufferDevice2Host_call& xclCopyBufferDevice2Host_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBufferDevice2Host_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBufferDevice2Host_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBufferDevice2Host_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      xcldevicehandle_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      dest_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x0000003cu) {
    ::memset(&src_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&space_) -
        reinterpret_cast<char*>(&src_)) + sizeof(space_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBufferDevice2Host_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bytes xclDeviceHandle = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_xcldevicehandle(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes dest = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dest(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 src = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_src(&has_bits);
          src_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 size = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 skip = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_skip(&has_bits);
          skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 space = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_space(&has_bits);
          space_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBufferDevice2Host_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBufferDevice2Host_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes xclDeviceHandle = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_xcldevicehandle()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes dest = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 src = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_src(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &src_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 size = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint64 skip = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_skip(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &skip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 space = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_space(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &space_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBufferDevice2Host_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBufferDevice2Host_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBufferDevice2Host_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBufferDevice2Host_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->xcldevicehandle(), output);
  }

  // required bytes dest = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->dest(), output);
  }

  // required uint64 src = 4;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->src(), output);
  }

  // required uint64 size = 5;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->size(), output);
  }

  // required uint64 skip = 6;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(6, this->skip(), output);
  }

  // optional uint32 space = 7;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(7, this->space(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBufferDevice2Host_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBufferDevice2Host_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBufferDevice2Host_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes xclDeviceHandle = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->xcldevicehandle(), target);
  }

  // required bytes dest = 3;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        3, this->dest(), target);
  }

  // required uint64 src = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->src(), target);
  }

  // required uint64 size = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->size(), target);
  }

  // required uint64 skip = 6;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->skip(), target);
  }

  // optional uint32 space = 7;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->space(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBufferDevice2Host_call)
  return target;
}

size_t xclCopyBufferDevice2Host_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclCopyBufferDevice2Host_call)
  size_t total_size = 0;

  if (has_xcldevicehandle()) {
    // required bytes xclDeviceHandle = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xcldevicehandle());
  }

  if (has_dest()) {
    // required bytes dest = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dest());
  }

  if (has_src()) {
    // required uint64 src = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->src());
  }

  if (has_size()) {
    // required uint64 size = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }

  if (has_skip()) {
    // required uint64 skip = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->skip());
  }

  return total_size;
}
size_t xclCopyBufferDevice2Host_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBufferDevice2Host_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required bytes xclDeviceHandle = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->xcldevicehandle());

    // required bytes dest = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dest());

    // required uint64 src = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->src());

    // required uint64 size = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());

    // required uint64 skip = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->skip());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 space = 7;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000020u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->space());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBufferDevice2Host_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBufferDevice2Host_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBufferDevice2Host_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBufferDevice2Host_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBufferDevice2Host_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBufferDevice2Host_call)
    MergeFrom(*source);
  }
}

void xclCopyBufferDevice2Host_call::MergeFrom(const xclCopyBufferDevice2Host_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBufferDevice2Host_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      xcldevicehandle_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.xcldevicehandle_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
    }
    if (cached_has_bits & 0x00000004u) {
      src_ = from.src_;
    }
    if (cached_has_bits & 0x00000008u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000010u) {
      skip_ = from.skip_;
    }
    if (cached_has_bits & 0x00000020u) {
      space_ = from.space_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclCopyBufferDevice2Host_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBufferDevice2Host_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclCopyBufferDevice2Host_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
  return true;
}

void xclCopyBufferDevice2Host_call::InternalSwap(xclCopyBufferDevice2Host_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  xcldevicehandle_.Swap(&other->xcldevicehandle_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  dest_.Swap(&other->dest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(src_, other->src_);
  swap(size_, other->size_);
  swap(skip_, other->skip_);
  swap(space_, other->space_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBufferDevice2Host_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBufferDevice2Host_response::InitAsDefaultInstance() {
}
class xclCopyBufferDevice2Host_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBufferDevice2Host_response>()._has_bits_);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclCopyBufferDevice2Host_response::xclCopyBufferDevice2Host_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBufferDevice2Host_response)
}
xclCopyBufferDevice2Host_response::xclCopyBufferDevice2Host_response(const xclCopyBufferDevice2Host_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dest()) {
    dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
  }
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:xclCopyBufferDevice2Host_response)
}

void xclCopyBufferDevice2Host_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto.base);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  size_ = PROTOBUF_ULONGLONG(0);
}

xclCopyBufferDevice2Host_response::~xclCopyBufferDevice2Host_response() {
  // @@protoc_insertion_point(destructor:xclCopyBufferDevice2Host_response)
  SharedDtor();
}

void xclCopyBufferDevice2Host_response::SharedDtor() {
  dest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclCopyBufferDevice2Host_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBufferDevice2Host_response& xclCopyBufferDevice2Host_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBufferDevice2Host_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBufferDevice2Host_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBufferDevice2Host_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dest_.ClearNonDefaultToEmptyNoArena();
  }
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBufferDevice2Host_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes dest = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dest(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBufferDevice2Host_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBufferDevice2Host_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 size = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes dest = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBufferDevice2Host_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBufferDevice2Host_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBufferDevice2Host_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBufferDevice2Host_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 size = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->size(), output);
  }

  // required bytes dest = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->dest(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBufferDevice2Host_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBufferDevice2Host_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBufferDevice2Host_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 size = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->size(), target);
  }

  // required bytes dest = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->dest(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBufferDevice2Host_response)
  return target;
}

size_t xclCopyBufferDevice2Host_response::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclCopyBufferDevice2Host_response)
  size_t total_size = 0;

  if (has_dest()) {
    // required bytes dest = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dest());
  }

  if (has_size()) {
    // required uint64 size = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());
  }

  return total_size;
}
size_t xclCopyBufferDevice2Host_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBufferDevice2Host_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required bytes dest = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->dest());

    // required uint64 size = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBufferDevice2Host_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBufferDevice2Host_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBufferDevice2Host_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBufferDevice2Host_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBufferDevice2Host_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBufferDevice2Host_response)
    MergeFrom(*source);
  }
}

void xclCopyBufferDevice2Host_response::MergeFrom(const xclCopyBufferDevice2Host_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBufferDevice2Host_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
    }
    if (cached_has_bits & 0x00000002u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclCopyBufferDevice2Host_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBufferDevice2Host_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclCopyBufferDevice2Host_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  return true;
}

void xclCopyBufferDevice2Host_response::InternalSwap(xclCopyBufferDevice2Host_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dest_.Swap(&other->dest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBufferDevice2Host_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteAddrSpaceDeviceRam_call::InitAsDefaultInstance() {
}
class xclWriteAddrSpaceDeviceRam_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteAddrSpaceDeviceRam_call>()._has_bits_);
  static void set_has_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteAddrSpaceDeviceRam_call::xclWriteAddrSpaceDeviceRam_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteAddrSpaceDeviceRam_call)
}
xclWriteAddrSpaceDeviceRam_call::xclWriteAddrSpaceDeviceRam_call(const xclWriteAddrSpaceDeviceRam_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  ::memcpy(&addr_, &from.addr_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclWriteAddrSpaceDeviceRam_call)
}

void xclWriteAddrSpaceDeviceRam_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&addr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&addr_)) + sizeof(size_));
}

xclWriteAddrSpaceDeviceRam_call::~xclWriteAddrSpaceDeviceRam_call() {
  // @@protoc_insertion_point(destructor:xclWriteAddrSpaceDeviceRam_call)
  SharedDtor();
}

void xclWriteAddrSpaceDeviceRam_call::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclWriteAddrSpaceDeviceRam_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteAddrSpaceDeviceRam_call& xclWriteAddrSpaceDeviceRam_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteAddrSpaceDeviceRam_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&addr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteAddrSpaceDeviceRam_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 addr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_addr(&has_bits);
          addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint32 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes data = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteAddrSpaceDeviceRam_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteAddrSpaceDeviceRam_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 addr = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_addr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &addr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint32 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes data = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteAddrSpaceDeviceRam_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteAddrSpaceDeviceRam_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteAddrSpaceDeviceRam_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->addr(), output);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->size(), output);
  }

  // required bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteAddrSpaceDeviceRam_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteAddrSpaceDeviceRam_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->addr(), target);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->size(), target);
  }

  // required bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteAddrSpaceDeviceRam_call)
  return target;
}

size_t xclWriteAddrSpaceDeviceRam_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclWriteAddrSpaceDeviceRam_call)
  size_t total_size = 0;

  if (has_data()) {
    // required bytes data = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  if (has_addr()) {
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());
  }

  if (has_size()) {
    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());
  }

  return total_size;
}
size_t xclWriteAddrSpaceDeviceRam_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteAddrSpaceDeviceRam_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required bytes data = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());

    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());

    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteAddrSpaceDeviceRam_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteAddrSpaceDeviceRam_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteAddrSpaceDeviceRam_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteAddrSpaceDeviceRam_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteAddrSpaceDeviceRam_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteAddrSpaceDeviceRam_call)
    MergeFrom(*source);
  }
}

void xclWriteAddrSpaceDeviceRam_call::MergeFrom(const xclWriteAddrSpaceDeviceRam_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteAddrSpaceDeviceRam_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      addr_ = from.addr_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclWriteAddrSpaceDeviceRam_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteAddrSpaceDeviceRam_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclWriteAddrSpaceDeviceRam_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  return true;
}

void xclWriteAddrSpaceDeviceRam_call::InternalSwap(xclWriteAddrSpaceDeviceRam_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(addr_, other->addr_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteAddrSpaceDeviceRam_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteAddrSpaceDeviceRam_response::InitAsDefaultInstance() {
}
class xclWriteAddrSpaceDeviceRam_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteAddrSpaceDeviceRam_response>()._has_bits_);
  static void set_has_valid(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteAddrSpaceDeviceRam_response::xclWriteAddrSpaceDeviceRam_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteAddrSpaceDeviceRam_response)
}
xclWriteAddrSpaceDeviceRam_response::xclWriteAddrSpaceDeviceRam_response(const xclWriteAddrSpaceDeviceRam_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  valid_ = from.valid_;
  // @@protoc_insertion_point(copy_constructor:xclWriteAddrSpaceDeviceRam_response)
}

void xclWriteAddrSpaceDeviceRam_response::SharedCtor() {
  valid_ = false;
}

xclWriteAddrSpaceDeviceRam_response::~xclWriteAddrSpaceDeviceRam_response() {
  // @@protoc_insertion_point(destructor:xclWriteAddrSpaceDeviceRam_response)
  SharedDtor();
}

void xclWriteAddrSpaceDeviceRam_response::SharedDtor() {
}

void xclWriteAddrSpaceDeviceRam_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteAddrSpaceDeviceRam_response& xclWriteAddrSpaceDeviceRam_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteAddrSpaceDeviceRam_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  valid_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteAddrSpaceDeviceRam_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool valid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_valid(&has_bits);
          valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteAddrSpaceDeviceRam_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteAddrSpaceDeviceRam_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool valid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_valid(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &valid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteAddrSpaceDeviceRam_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteAddrSpaceDeviceRam_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteAddrSpaceDeviceRam_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->valid(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteAddrSpaceDeviceRam_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteAddrSpaceDeviceRam_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->valid(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteAddrSpaceDeviceRam_response)
  return target;
}

size_t xclWriteAddrSpaceDeviceRam_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteAddrSpaceDeviceRam_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool valid = 1;
  if (has_valid()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteAddrSpaceDeviceRam_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteAddrSpaceDeviceRam_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteAddrSpaceDeviceRam_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteAddrSpaceDeviceRam_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteAddrSpaceDeviceRam_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteAddrSpaceDeviceRam_response)
    MergeFrom(*source);
  }
}

void xclWriteAddrSpaceDeviceRam_response::MergeFrom(const xclWriteAddrSpaceDeviceRam_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteAddrSpaceDeviceRam_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_valid()) {
    set_valid(from.valid());
  }
}

void xclWriteAddrSpaceDeviceRam_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteAddrSpaceDeviceRam_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclWriteAddrSpaceDeviceRam_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclWriteAddrSpaceDeviceRam_response::InternalSwap(xclWriteAddrSpaceDeviceRam_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(valid_, other->valid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteAddrSpaceDeviceRam_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteAddrKernelCtrl_call_kernelInfo::InitAsDefaultInstance() {
}
class xclWriteAddrKernelCtrl_call_kernelInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteAddrKernelCtrl_call_kernelInfo>()._has_bits_);
  static void set_has_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteAddrKernelCtrl_call_kernelInfo::xclWriteAddrKernelCtrl_call_kernelInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteAddrKernelCtrl_call.kernelInfo)
}
xclWriteAddrKernelCtrl_call_kernelInfo::xclWriteAddrKernelCtrl_call_kernelInfo(const xclWriteAddrKernelCtrl_call_kernelInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  ::memcpy(&addr_, &from.addr_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclWriteAddrKernelCtrl_call.kernelInfo)
}

void xclWriteAddrKernelCtrl_call_kernelInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&addr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&addr_)) + sizeof(size_));
}

xclWriteAddrKernelCtrl_call_kernelInfo::~xclWriteAddrKernelCtrl_call_kernelInfo() {
  // @@protoc_insertion_point(destructor:xclWriteAddrKernelCtrl_call.kernelInfo)
  SharedDtor();
}

void xclWriteAddrKernelCtrl_call_kernelInfo::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclWriteAddrKernelCtrl_call_kernelInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteAddrKernelCtrl_call_kernelInfo& xclWriteAddrKernelCtrl_call_kernelInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteAddrKernelCtrl_call_kernelInfo_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteAddrKernelCtrl_call_kernelInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&addr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteAddrKernelCtrl_call_kernelInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 addr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_addr(&has_bits);
          addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string name = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "xclWriteAddrKernelCtrl_call.kernelInfo.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteAddrKernelCtrl_call_kernelInfo::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 addr = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_addr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &addr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 size = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string name = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclWriteAddrKernelCtrl_call.kernelInfo.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteAddrKernelCtrl_call.kernelInfo)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteAddrKernelCtrl_call.kernelInfo)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteAddrKernelCtrl_call_kernelInfo::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 addr = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->addr(), output);
  }

  // optional uint32 size = 2;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->size(), output);
  }

  // optional string name = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclWriteAddrKernelCtrl_call.kernelInfo.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->name(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteAddrKernelCtrl_call.kernelInfo)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteAddrKernelCtrl_call_kernelInfo::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 addr = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->addr(), target);
  }

  // optional uint32 size = 2;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->size(), target);
  }

  // optional string name = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclWriteAddrKernelCtrl_call.kernelInfo.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        3, this->name(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteAddrKernelCtrl_call.kernelInfo)
  return target;
}

size_t xclWriteAddrKernelCtrl_call_kernelInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string name = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional uint64 addr = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->addr());
    }

    // optional uint32 size = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->size());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteAddrKernelCtrl_call_kernelInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteAddrKernelCtrl_call_kernelInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteAddrKernelCtrl_call_kernelInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteAddrKernelCtrl_call.kernelInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteAddrKernelCtrl_call.kernelInfo)
    MergeFrom(*source);
  }
}

void xclWriteAddrKernelCtrl_call_kernelInfo::MergeFrom(const xclWriteAddrKernelCtrl_call_kernelInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      addr_ = from.addr_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclWriteAddrKernelCtrl_call_kernelInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteAddrKernelCtrl_call.kernelInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclWriteAddrKernelCtrl_call_kernelInfo::InternalSwap(xclWriteAddrKernelCtrl_call_kernelInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(addr_, other->addr_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteAddrKernelCtrl_call_kernelInfo::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteAddrKernelCtrl_call::InitAsDefaultInstance() {
}
class xclWriteAddrKernelCtrl_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteAddrKernelCtrl_call>()._has_bits_);
  static void set_has_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteAddrKernelCtrl_call::xclWriteAddrKernelCtrl_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteAddrKernelCtrl_call)
}
xclWriteAddrKernelCtrl_call::xclWriteAddrKernelCtrl_call(const xclWriteAddrKernelCtrl_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      kernel_info_(from.kernel_info_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  ::memcpy(&addr_, &from.addr_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclWriteAddrKernelCtrl_call)
}

void xclWriteAddrKernelCtrl_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&addr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&addr_)) + sizeof(size_));
}

xclWriteAddrKernelCtrl_call::~xclWriteAddrKernelCtrl_call() {
  // @@protoc_insertion_point(destructor:xclWriteAddrKernelCtrl_call)
  SharedDtor();
}

void xclWriteAddrKernelCtrl_call::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclWriteAddrKernelCtrl_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteAddrKernelCtrl_call& xclWriteAddrKernelCtrl_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteAddrKernelCtrl_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteAddrKernelCtrl_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  kernel_info_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&addr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteAddrKernelCtrl_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 addr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_addr(&has_bits);
          addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint32 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required bytes data = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_kernel_info(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteAddrKernelCtrl_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteAddrKernelCtrl_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 addr = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_addr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &addr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint32 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes data = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_kernel_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteAddrKernelCtrl_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteAddrKernelCtrl_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteAddrKernelCtrl_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->addr(), output);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->size(), output);
  }

  // required bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->kernel_info_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5,
      this->kernel_info(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteAddrKernelCtrl_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteAddrKernelCtrl_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->addr(), target);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->size(), target);
  }

  // required bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->kernel_info_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, this->kernel_info(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteAddrKernelCtrl_call)
  return target;
}

size_t xclWriteAddrKernelCtrl_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclWriteAddrKernelCtrl_call)
  size_t total_size = 0;

  if (has_data()) {
    // required bytes data = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  if (has_addr()) {
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());
  }

  if (has_size()) {
    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());
  }

  return total_size;
}
size_t xclWriteAddrKernelCtrl_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteAddrKernelCtrl_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required bytes data = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());

    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());

    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclWriteAddrKernelCtrl_call.kernelInfo kernel_info = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->kernel_info_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->kernel_info(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteAddrKernelCtrl_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteAddrKernelCtrl_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteAddrKernelCtrl_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteAddrKernelCtrl_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteAddrKernelCtrl_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteAddrKernelCtrl_call)
    MergeFrom(*source);
  }
}

void xclWriteAddrKernelCtrl_call::MergeFrom(const xclWriteAddrKernelCtrl_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteAddrKernelCtrl_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  kernel_info_.MergeFrom(from.kernel_info_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      addr_ = from.addr_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclWriteAddrKernelCtrl_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteAddrKernelCtrl_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclWriteAddrKernelCtrl_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  return true;
}

void xclWriteAddrKernelCtrl_call::InternalSwap(xclWriteAddrKernelCtrl_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&kernel_info_)->InternalSwap(CastToBase(&other->kernel_info_));
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(addr_, other->addr_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteAddrKernelCtrl_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteAddrKernelCtrl_response::InitAsDefaultInstance() {
}
class xclWriteAddrKernelCtrl_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteAddrKernelCtrl_response>()._has_bits_);
  static void set_has_valid(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteAddrKernelCtrl_response::xclWriteAddrKernelCtrl_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteAddrKernelCtrl_response)
}
xclWriteAddrKernelCtrl_response::xclWriteAddrKernelCtrl_response(const xclWriteAddrKernelCtrl_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  valid_ = from.valid_;
  // @@protoc_insertion_point(copy_constructor:xclWriteAddrKernelCtrl_response)
}

void xclWriteAddrKernelCtrl_response::SharedCtor() {
  valid_ = false;
}

xclWriteAddrKernelCtrl_response::~xclWriteAddrKernelCtrl_response() {
  // @@protoc_insertion_point(destructor:xclWriteAddrKernelCtrl_response)
  SharedDtor();
}

void xclWriteAddrKernelCtrl_response::SharedDtor() {
}

void xclWriteAddrKernelCtrl_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteAddrKernelCtrl_response& xclWriteAddrKernelCtrl_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteAddrKernelCtrl_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteAddrKernelCtrl_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  valid_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteAddrKernelCtrl_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool valid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_valid(&has_bits);
          valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteAddrKernelCtrl_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteAddrKernelCtrl_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool valid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_valid(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &valid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteAddrKernelCtrl_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteAddrKernelCtrl_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteAddrKernelCtrl_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->valid(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteAddrKernelCtrl_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteAddrKernelCtrl_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->valid(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteAddrKernelCtrl_response)
  return target;
}

size_t xclWriteAddrKernelCtrl_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteAddrKernelCtrl_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool valid = 1;
  if (has_valid()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteAddrKernelCtrl_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteAddrKernelCtrl_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteAddrKernelCtrl_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteAddrKernelCtrl_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteAddrKernelCtrl_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteAddrKernelCtrl_response)
    MergeFrom(*source);
  }
}

void xclWriteAddrKernelCtrl_response::MergeFrom(const xclWriteAddrKernelCtrl_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteAddrKernelCtrl_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_valid()) {
    set_valid(from.valid());
  }
}

void xclWriteAddrKernelCtrl_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteAddrKernelCtrl_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclWriteAddrKernelCtrl_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclWriteAddrKernelCtrl_response::InternalSwap(xclWriteAddrKernelCtrl_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(valid_, other->valid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteAddrKernelCtrl_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadAddrSpaceDeviceRam_call::InitAsDefaultInstance() {
}
class xclReadAddrSpaceDeviceRam_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadAddrSpaceDeviceRam_call>()._has_bits_);
  static void set_has_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclReadAddrSpaceDeviceRam_call::xclReadAddrSpaceDeviceRam_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadAddrSpaceDeviceRam_call)
}
xclReadAddrSpaceDeviceRam_call::xclReadAddrSpaceDeviceRam_call(const xclReadAddrSpaceDeviceRam_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  ::memcpy(&addr_, &from.addr_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclReadAddrSpaceDeviceRam_call)
}

void xclReadAddrSpaceDeviceRam_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&addr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&addr_)) + sizeof(size_));
}

xclReadAddrSpaceDeviceRam_call::~xclReadAddrSpaceDeviceRam_call() {
  // @@protoc_insertion_point(destructor:xclReadAddrSpaceDeviceRam_call)
  SharedDtor();
}

void xclReadAddrSpaceDeviceRam_call::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadAddrSpaceDeviceRam_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadAddrSpaceDeviceRam_call& xclReadAddrSpaceDeviceRam_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadAddrSpaceDeviceRam_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadAddrSpaceDeviceRam_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&addr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadAddrSpaceDeviceRam_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 addr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_addr(&has_bits);
          addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint32 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadAddrSpaceDeviceRam_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadAddrSpaceDeviceRam_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 addr = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_addr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &addr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint32 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes data = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadAddrSpaceDeviceRam_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadAddrSpaceDeviceRam_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadAddrSpaceDeviceRam_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->addr(), output);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->size(), output);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadAddrSpaceDeviceRam_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadAddrSpaceDeviceRam_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadAddrSpaceDeviceRam_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->addr(), target);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->size(), target);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadAddrSpaceDeviceRam_call)
  return target;
}

size_t xclReadAddrSpaceDeviceRam_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclReadAddrSpaceDeviceRam_call)
  size_t total_size = 0;

  if (has_addr()) {
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());
  }

  if (has_size()) {
    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());
  }

  return total_size;
}
size_t xclReadAddrSpaceDeviceRam_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadAddrSpaceDeviceRam_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) {  // All required fields are present.
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());

    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 4;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadAddrSpaceDeviceRam_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadAddrSpaceDeviceRam_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadAddrSpaceDeviceRam_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadAddrSpaceDeviceRam_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadAddrSpaceDeviceRam_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadAddrSpaceDeviceRam_call)
    MergeFrom(*source);
  }
}

void xclReadAddrSpaceDeviceRam_call::MergeFrom(const xclReadAddrSpaceDeviceRam_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadAddrSpaceDeviceRam_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      addr_ = from.addr_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadAddrSpaceDeviceRam_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadAddrSpaceDeviceRam_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclReadAddrSpaceDeviceRam_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
  return true;
}

void xclReadAddrSpaceDeviceRam_call::InternalSwap(xclReadAddrSpaceDeviceRam_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(addr_, other->addr_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadAddrSpaceDeviceRam_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadAddrSpaceDeviceRam_response::InitAsDefaultInstance() {
}
class xclReadAddrSpaceDeviceRam_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadAddrSpaceDeviceRam_response>()._has_bits_);
  static void set_has_valid(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclReadAddrSpaceDeviceRam_response::xclReadAddrSpaceDeviceRam_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadAddrSpaceDeviceRam_response)
}
xclReadAddrSpaceDeviceRam_response::xclReadAddrSpaceDeviceRam_response(const xclReadAddrSpaceDeviceRam_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  valid_ = from.valid_;
  // @@protoc_insertion_point(copy_constructor:xclReadAddrSpaceDeviceRam_response)
}

void xclReadAddrSpaceDeviceRam_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  valid_ = false;
}

xclReadAddrSpaceDeviceRam_response::~xclReadAddrSpaceDeviceRam_response() {
  // @@protoc_insertion_point(destructor:xclReadAddrSpaceDeviceRam_response)
  SharedDtor();
}

void xclReadAddrSpaceDeviceRam_response::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadAddrSpaceDeviceRam_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadAddrSpaceDeviceRam_response& xclReadAddrSpaceDeviceRam_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadAddrSpaceDeviceRam_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadAddrSpaceDeviceRam_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  valid_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadAddrSpaceDeviceRam_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool valid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_valid(&has_bits);
          valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadAddrSpaceDeviceRam_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadAddrSpaceDeviceRam_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool valid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_valid(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &valid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes data = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadAddrSpaceDeviceRam_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadAddrSpaceDeviceRam_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadAddrSpaceDeviceRam_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->valid(), output);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadAddrSpaceDeviceRam_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadAddrSpaceDeviceRam_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadAddrSpaceDeviceRam_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->valid(), target);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadAddrSpaceDeviceRam_response)
  return target;
}

size_t xclReadAddrSpaceDeviceRam_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadAddrSpaceDeviceRam_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool valid = 1;
  if (has_valid()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadAddrSpaceDeviceRam_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadAddrSpaceDeviceRam_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadAddrSpaceDeviceRam_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadAddrSpaceDeviceRam_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadAddrSpaceDeviceRam_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadAddrSpaceDeviceRam_response)
    MergeFrom(*source);
  }
}

void xclReadAddrSpaceDeviceRam_response::MergeFrom(const xclReadAddrSpaceDeviceRam_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadAddrSpaceDeviceRam_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      valid_ = from.valid_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadAddrSpaceDeviceRam_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadAddrSpaceDeviceRam_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclReadAddrSpaceDeviceRam_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
  return true;
}

void xclReadAddrSpaceDeviceRam_response::InternalSwap(xclReadAddrSpaceDeviceRam_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(valid_, other->valid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadAddrSpaceDeviceRam_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadAddrKernelCtrl_call::InitAsDefaultInstance() {
}
class xclReadAddrKernelCtrl_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadAddrKernelCtrl_call>()._has_bits_);
  static void set_has_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclReadAddrKernelCtrl_call::xclReadAddrKernelCtrl_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadAddrKernelCtrl_call)
}
xclReadAddrKernelCtrl_call::xclReadAddrKernelCtrl_call(const xclReadAddrKernelCtrl_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  ::memcpy(&addr_, &from.addr_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclReadAddrKernelCtrl_call)
}

void xclReadAddrKernelCtrl_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&addr_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&addr_)) + sizeof(size_));
}

xclReadAddrKernelCtrl_call::~xclReadAddrKernelCtrl_call() {
  // @@protoc_insertion_point(destructor:xclReadAddrKernelCtrl_call)
  SharedDtor();
}

void xclReadAddrKernelCtrl_call::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadAddrKernelCtrl_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadAddrKernelCtrl_call& xclReadAddrKernelCtrl_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadAddrKernelCtrl_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadAddrKernelCtrl_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&addr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&addr_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadAddrKernelCtrl_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 addr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_addr(&has_bits);
          addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint32 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadAddrKernelCtrl_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadAddrKernelCtrl_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 addr = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_addr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &addr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint32 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes data = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadAddrKernelCtrl_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadAddrKernelCtrl_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadAddrKernelCtrl_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->addr(), output);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->size(), output);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadAddrKernelCtrl_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadAddrKernelCtrl_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadAddrKernelCtrl_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 addr = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->addr(), target);
  }

  // required uint32 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->size(), target);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadAddrKernelCtrl_call)
  return target;
}

size_t xclReadAddrKernelCtrl_call::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:xclReadAddrKernelCtrl_call)
  size_t total_size = 0;

  if (has_addr()) {
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());
  }

  if (has_size()) {
    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());
  }

  return total_size;
}
size_t xclReadAddrKernelCtrl_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadAddrKernelCtrl_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) {  // All required fields are present.
    // required uint64 addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->addr());

    // required uint32 size = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 4;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadAddrKernelCtrl_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadAddrKernelCtrl_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadAddrKernelCtrl_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadAddrKernelCtrl_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadAddrKernelCtrl_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadAddrKernelCtrl_call)
    MergeFrom(*source);
  }
}

void xclReadAddrKernelCtrl_call::MergeFrom(const xclReadAddrKernelCtrl_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadAddrKernelCtrl_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      addr_ = from.addr_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadAddrKernelCtrl_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadAddrKernelCtrl_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclReadAddrKernelCtrl_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
  return true;
}

void xclReadAddrKernelCtrl_call::InternalSwap(xclReadAddrKernelCtrl_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(addr_, other->addr_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadAddrKernelCtrl_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadAddrKernelCtrl_response::InitAsDefaultInstance() {
}
class xclReadAddrKernelCtrl_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadAddrKernelCtrl_response>()._has_bits_);
  static void set_has_valid(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclReadAddrKernelCtrl_response::xclReadAddrKernelCtrl_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadAddrKernelCtrl_response)
}
xclReadAddrKernelCtrl_response::xclReadAddrKernelCtrl_response(const xclReadAddrKernelCtrl_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  valid_ = from.valid_;
  // @@protoc_insertion_point(copy_constructor:xclReadAddrKernelCtrl_response)
}

void xclReadAddrKernelCtrl_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  valid_ = false;
}

xclReadAddrKernelCtrl_response::~xclReadAddrKernelCtrl_response() {
  // @@protoc_insertion_point(destructor:xclReadAddrKernelCtrl_response)
  SharedDtor();
}

void xclReadAddrKernelCtrl_response::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadAddrKernelCtrl_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadAddrKernelCtrl_response& xclReadAddrKernelCtrl_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadAddrKernelCtrl_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadAddrKernelCtrl_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  valid_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadAddrKernelCtrl_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bool valid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_valid(&has_bits);
          valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadAddrKernelCtrl_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadAddrKernelCtrl_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool valid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_valid(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &valid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes data = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadAddrKernelCtrl_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadAddrKernelCtrl_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadAddrKernelCtrl_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->valid(), output);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadAddrKernelCtrl_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadAddrKernelCtrl_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadAddrKernelCtrl_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bool valid = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->valid(), target);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadAddrKernelCtrl_response)
  return target;
}

size_t xclReadAddrKernelCtrl_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadAddrKernelCtrl_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bool valid = 1;
  if (has_valid()) {
    total_size += 1 + 1;
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadAddrKernelCtrl_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadAddrKernelCtrl_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadAddrKernelCtrl_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadAddrKernelCtrl_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadAddrKernelCtrl_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadAddrKernelCtrl_response)
    MergeFrom(*source);
  }
}

void xclReadAddrKernelCtrl_response::MergeFrom(const xclReadAddrKernelCtrl_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadAddrKernelCtrl_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      valid_ = from.valid_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadAddrKernelCtrl_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadAddrKernelCtrl_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclReadAddrKernelCtrl_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
  return true;
}

void xclReadAddrKernelCtrl_response::InternalSwap(xclReadAddrKernelCtrl_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(valid_, other->valid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadAddrKernelCtrl_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadCounters_call::InitAsDefaultInstance() {
}
class xclPerfMonReadCounters_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadCounters_call>()._has_bits_);
  static void set_has_slotname(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_accel(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclPerfMonReadCounters_call::xclPerfMonReadCounters_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadCounters_call)
}
xclPerfMonReadCounters_call::xclPerfMonReadCounters_call(const xclPerfMonReadCounters_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_slotname()) {
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
  accel_ = from.accel_;
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadCounters_call)
}

void xclPerfMonReadCounters_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto.base);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  accel_ = false;
}

xclPerfMonReadCounters_call::~xclPerfMonReadCounters_call() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadCounters_call)
  SharedDtor();
}

void xclPerfMonReadCounters_call::SharedDtor() {
  slotname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPerfMonReadCounters_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadCounters_call& xclPerfMonReadCounters_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadCounters_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadCounters_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadCounters_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    slotname_.ClearNonDefaultToEmptyNoArena();
  }
  accel_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadCounters_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required string slotname = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_slotname(), ptr, ctx, "xclPerfMonReadCounters_call.slotname");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool accel = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_accel(&has_bits);
          accel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadCounters_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadCounters_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string slotname = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_slotname()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->slotname().data(), static_cast<int>(this->slotname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclPerfMonReadCounters_call.slotname");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool accel = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_accel(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &accel_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadCounters_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadCounters_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadCounters_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadCounters_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string slotname = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadCounters_call.slotname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->slotname(), output);
  }

  // optional bool accel = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->accel(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadCounters_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadCounters_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadCounters_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string slotname = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadCounters_call.slotname");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->slotname(), target);
  }

  // optional bool accel = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->accel(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadCounters_call)
  return target;
}

size_t xclPerfMonReadCounters_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadCounters_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required string slotname = 1;
  if (has_slotname()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->slotname());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool accel = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadCounters_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadCounters_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadCounters_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadCounters_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadCounters_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadCounters_call)
    MergeFrom(*source);
  }
}

void xclPerfMonReadCounters_call::MergeFrom(const xclPerfMonReadCounters_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadCounters_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
    }
    if (cached_has_bits & 0x00000002u) {
      accel_ = from.accel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadCounters_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadCounters_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclPerfMonReadCounters_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclPerfMonReadCounters_call::InternalSwap(xclPerfMonReadCounters_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  slotname_.Swap(&other->slotname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(accel_, other->accel_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadCounters_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadCounters_response::InitAsDefaultInstance() {
}
class xclPerfMonReadCounters_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadCounters_response>()._has_bits_);
  static void set_has_wr_byte_count(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_wr_trans_count(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_total_wr_latency(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_rd_byte_count(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_rd_trans_count(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_total_rd_latency(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclPerfMonReadCounters_response::xclPerfMonReadCounters_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadCounters_response)
}
xclPerfMonReadCounters_response::xclPerfMonReadCounters_response(const xclPerfMonReadCounters_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&wr_byte_count_, &from.wr_byte_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&total_rd_latency_) -
    reinterpret_cast<char*>(&wr_byte_count_)) + sizeof(total_rd_latency_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadCounters_response)
}

void xclPerfMonReadCounters_response::SharedCtor() {
  ::memset(&wr_byte_count_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&total_rd_latency_) -
      reinterpret_cast<char*>(&wr_byte_count_)) + sizeof(total_rd_latency_));
}

xclPerfMonReadCounters_response::~xclPerfMonReadCounters_response() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadCounters_response)
  SharedDtor();
}

void xclPerfMonReadCounters_response::SharedDtor() {
}

void xclPerfMonReadCounters_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadCounters_response& xclPerfMonReadCounters_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadCounters_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadCounters_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadCounters_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&wr_byte_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_rd_latency_) -
        reinterpret_cast<char*>(&wr_byte_count_)) + sizeof(total_rd_latency_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadCounters_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 wr_byte_count = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_wr_byte_count(&has_bits);
          wr_byte_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 wr_trans_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_wr_trans_count(&has_bits);
          wr_trans_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 total_wr_latency = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_total_wr_latency(&has_bits);
          total_wr_latency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 rd_byte_count = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_rd_byte_count(&has_bits);
          rd_byte_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 rd_trans_count = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_rd_trans_count(&has_bits);
          rd_trans_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 total_rd_latency = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_total_rd_latency(&has_bits);
          total_rd_latency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadCounters_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadCounters_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 wr_byte_count = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_wr_byte_count(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &wr_byte_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 wr_trans_count = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_wr_trans_count(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &wr_trans_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 total_wr_latency = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_total_wr_latency(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &total_wr_latency_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rd_byte_count = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_rd_byte_count(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rd_byte_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rd_trans_count = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_rd_trans_count(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rd_trans_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 total_rd_latency = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_total_rd_latency(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &total_rd_latency_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadCounters_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadCounters_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadCounters_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadCounters_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 wr_byte_count = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->wr_byte_count(), output);
  }

  // optional uint32 wr_trans_count = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->wr_trans_count(), output);
  }

  // optional uint32 total_wr_latency = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->total_wr_latency(), output);
  }

  // optional uint32 rd_byte_count = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->rd_byte_count(), output);
  }

  // optional uint32 rd_trans_count = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(5, this->rd_trans_count(), output);
  }

  // optional uint32 total_rd_latency = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(6, this->total_rd_latency(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadCounters_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadCounters_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadCounters_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 wr_byte_count = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->wr_byte_count(), target);
  }

  // optional uint32 wr_trans_count = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->wr_trans_count(), target);
  }

  // optional uint32 total_wr_latency = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->total_wr_latency(), target);
  }

  // optional uint32 rd_byte_count = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->rd_byte_count(), target);
  }

  // optional uint32 rd_trans_count = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->rd_trans_count(), target);
  }

  // optional uint32 total_rd_latency = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->total_rd_latency(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadCounters_response)
  return target;
}

size_t xclPerfMonReadCounters_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadCounters_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional uint32 wr_byte_count = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->wr_byte_count());
    }

    // optional uint32 wr_trans_count = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->wr_trans_count());
    }

    // optional uint32 total_wr_latency = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->total_wr_latency());
    }

    // optional uint32 rd_byte_count = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->rd_byte_count());
    }

    // optional uint32 rd_trans_count = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->rd_trans_count());
    }

    // optional uint32 total_rd_latency = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->total_rd_latency());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadCounters_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadCounters_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadCounters_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadCounters_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadCounters_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadCounters_response)
    MergeFrom(*source);
  }
}

void xclPerfMonReadCounters_response::MergeFrom(const xclPerfMonReadCounters_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadCounters_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      wr_byte_count_ = from.wr_byte_count_;
    }
    if (cached_has_bits & 0x00000002u) {
      wr_trans_count_ = from.wr_trans_count_;
    }
    if (cached_has_bits & 0x00000004u) {
      total_wr_latency_ = from.total_wr_latency_;
    }
    if (cached_has_bits & 0x00000008u) {
      rd_byte_count_ = from.rd_byte_count_;
    }
    if (cached_has_bits & 0x00000010u) {
      rd_trans_count_ = from.rd_trans_count_;
    }
    if (cached_has_bits & 0x00000020u) {
      total_rd_latency_ = from.total_rd_latency_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadCounters_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadCounters_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadCounters_response::InternalSwap(xclPerfMonReadCounters_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(wr_byte_count_, other->wr_byte_count_);
  swap(wr_trans_count_, other->wr_trans_count_);
  swap(total_wr_latency_, other->total_wr_latency_);
  swap(rd_byte_count_, other->rd_byte_count_);
  swap(rd_trans_count_, other->rd_trans_count_);
  swap(total_rd_latency_, other->total_rd_latency_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadCounters_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonGetTraceCount_call::InitAsDefaultInstance() {
}
class xclPerfMonGetTraceCount_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonGetTraceCount_call>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_slotname(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_accel(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclPerfMonGetTraceCount_call::xclPerfMonGetTraceCount_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonGetTraceCount_call)
}
xclPerfMonGetTraceCount_call::xclPerfMonGetTraceCount_call(const xclPerfMonGetTraceCount_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_slotname()) {
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
  ::memcpy(&ack_, &from.ack_,
    static_cast<size_t>(reinterpret_cast<char*>(&accel_) -
    reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonGetTraceCount_call)
}

void xclPerfMonGetTraceCount_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto.base);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accel_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
}

xclPerfMonGetTraceCount_call::~xclPerfMonGetTraceCount_call() {
  // @@protoc_insertion_point(destructor:xclPerfMonGetTraceCount_call)
  SharedDtor();
}

void xclPerfMonGetTraceCount_call::SharedDtor() {
  slotname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPerfMonGetTraceCount_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonGetTraceCount_call& xclPerfMonGetTraceCount_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonGetTraceCount_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonGetTraceCount_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonGetTraceCount_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    slotname_.ClearNonDefaultToEmptyNoArena();
  }
  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accel_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonGetTraceCount_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string slotname = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_slotname(), ptr, ctx, "xclPerfMonGetTraceCount_call.slotname");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool accel = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_accel(&has_bits);
          accel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonGetTraceCount_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonGetTraceCount_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string slotname = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_slotname()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->slotname().data(), static_cast<int>(this->slotname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclPerfMonGetTraceCount_call.slotname");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool accel = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_accel(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &accel_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonGetTraceCount_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonGetTraceCount_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonGetTraceCount_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonGetTraceCount_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonGetTraceCount_call.slotname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->slotname(), output);
  }

  // optional bool accel = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->accel(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonGetTraceCount_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonGetTraceCount_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonGetTraceCount_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonGetTraceCount_call.slotname");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->slotname(), target);
  }

  // optional bool accel = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->accel(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonGetTraceCount_call)
  return target;
}

size_t xclPerfMonGetTraceCount_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonGetTraceCount_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string slotname = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->slotname());
    }

    // optional bool ack = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional bool accel = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonGetTraceCount_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonGetTraceCount_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonGetTraceCount_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonGetTraceCount_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonGetTraceCount_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonGetTraceCount_call)
    MergeFrom(*source);
  }
}

void xclPerfMonGetTraceCount_call::MergeFrom(const xclPerfMonGetTraceCount_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonGetTraceCount_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
    }
    if (cached_has_bits & 0x00000002u) {
      ack_ = from.ack_;
    }
    if (cached_has_bits & 0x00000004u) {
      accel_ = from.accel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonGetTraceCount_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonGetTraceCount_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonGetTraceCount_call::InternalSwap(xclPerfMonGetTraceCount_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  slotname_.Swap(&other->slotname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(ack_, other->ack_);
  swap(accel_, other->accel_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonGetTraceCount_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonGetTraceCount_response::InitAsDefaultInstance() {
}
class xclPerfMonGetTraceCount_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonGetTraceCount_response>()._has_bits_);
  static void set_has_no_of_samples(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclPerfMonGetTraceCount_response::xclPerfMonGetTraceCount_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonGetTraceCount_response)
}
xclPerfMonGetTraceCount_response::xclPerfMonGetTraceCount_response(const xclPerfMonGetTraceCount_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  no_of_samples_ = from.no_of_samples_;
  // @@protoc_insertion_point(copy_constructor:xclPerfMonGetTraceCount_response)
}

void xclPerfMonGetTraceCount_response::SharedCtor() {
  no_of_samples_ = 0u;
}

xclPerfMonGetTraceCount_response::~xclPerfMonGetTraceCount_response() {
  // @@protoc_insertion_point(destructor:xclPerfMonGetTraceCount_response)
  SharedDtor();
}

void xclPerfMonGetTraceCount_response::SharedDtor() {
}

void xclPerfMonGetTraceCount_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonGetTraceCount_response& xclPerfMonGetTraceCount_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonGetTraceCount_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonGetTraceCount_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonGetTraceCount_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  no_of_samples_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonGetTraceCount_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 no_of_samples = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_no_of_samples(&has_bits);
          no_of_samples_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonGetTraceCount_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonGetTraceCount_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 no_of_samples = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_no_of_samples(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &no_of_samples_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonGetTraceCount_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonGetTraceCount_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonGetTraceCount_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonGetTraceCount_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 no_of_samples = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->no_of_samples(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonGetTraceCount_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonGetTraceCount_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonGetTraceCount_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 no_of_samples = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->no_of_samples(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonGetTraceCount_response)
  return target;
}

size_t xclPerfMonGetTraceCount_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonGetTraceCount_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 no_of_samples = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->no_of_samples());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonGetTraceCount_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonGetTraceCount_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonGetTraceCount_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonGetTraceCount_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonGetTraceCount_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonGetTraceCount_response)
    MergeFrom(*source);
  }
}

void xclPerfMonGetTraceCount_response::MergeFrom(const xclPerfMonGetTraceCount_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonGetTraceCount_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_no_of_samples()) {
    set_no_of_samples(from.no_of_samples());
  }
}

void xclPerfMonGetTraceCount_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonGetTraceCount_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonGetTraceCount_response::InternalSwap(xclPerfMonGetTraceCount_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(no_of_samples_, other->no_of_samples_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonGetTraceCount_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_call::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_call>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_slotname(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_accel(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclPerfMonReadTrace_call::xclPerfMonReadTrace_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_call)
}
xclPerfMonReadTrace_call::xclPerfMonReadTrace_call(const xclPerfMonReadTrace_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_slotname()) {
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
  ::memcpy(&ack_, &from.ack_,
    static_cast<size_t>(reinterpret_cast<char*>(&accel_) -
    reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_call)
}

void xclPerfMonReadTrace_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto.base);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accel_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
}

xclPerfMonReadTrace_call::~xclPerfMonReadTrace_call() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_call)
  SharedDtor();
}

void xclPerfMonReadTrace_call::SharedDtor() {
  slotname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPerfMonReadTrace_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_call& xclPerfMonReadTrace_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    slotname_.ClearNonDefaultToEmptyNoArena();
  }
  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accel_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(accel_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string slotname = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_slotname(), ptr, ctx, "xclPerfMonReadTrace_call.slotname");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool accel = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_accel(&has_bits);
          accel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string slotname = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_slotname()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->slotname().data(), static_cast<int>(this->slotname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclPerfMonReadTrace_call.slotname");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool accel = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_accel(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &accel_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadTrace_call.slotname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->slotname(), output);
  }

  // optional bool accel = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->accel(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadTrace_call.slotname");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->slotname(), target);
  }

  // optional bool accel = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->accel(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_call)
  return target;
}

size_t xclPerfMonReadTrace_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string slotname = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->slotname());
    }

    // optional bool ack = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional bool accel = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_call)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_call::MergeFrom(const xclPerfMonReadTrace_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
    }
    if (cached_has_bits & 0x00000002u) {
      ack_ = from.ack_;
    }
    if (cached_has_bits & 0x00000004u) {
      accel_ = from.accel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadTrace_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_call::InternalSwap(xclPerfMonReadTrace_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  slotname_.Swap(&other->slotname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(ack_, other->ack_);
  swap(accel_, other->accel_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_response_events::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_response_events::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_response_events>()._has_bits_);
  static void set_has_awlen(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_arlen(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_eventflags(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_host_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_rd_bytes(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_wr_bytes(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
};

xclPerfMonReadTrace_response_events::xclPerfMonReadTrace_response_events()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_response.events)
}
xclPerfMonReadTrace_response_events::xclPerfMonReadTrace_response_events(const xclPerfMonReadTrace_response_events& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&awlen_, &from.awlen_,
    static_cast<size_t>(reinterpret_cast<char*>(&wr_bytes_) -
    reinterpret_cast<char*>(&awlen_)) + sizeof(wr_bytes_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_response.events)
}

void xclPerfMonReadTrace_response_events::SharedCtor() {
  ::memset(&awlen_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&wr_bytes_) -
      reinterpret_cast<char*>(&awlen_)) + sizeof(wr_bytes_));
}

xclPerfMonReadTrace_response_events::~xclPerfMonReadTrace_response_events() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_response.events)
  SharedDtor();
}

void xclPerfMonReadTrace_response_events::SharedDtor() {
}

void xclPerfMonReadTrace_response_events::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_response_events& xclPerfMonReadTrace_response_events::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_response_events_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_response_events::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    ::memset(&awlen_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&wr_bytes_) -
        reinterpret_cast<char*>(&awlen_)) + sizeof(wr_bytes_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_response_events::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 awlen = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_awlen(&has_bits);
          awlen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 arlen = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_arlen(&has_bits);
          arlen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 eventflags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_eventflags(&has_bits);
          eventflags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 timestamp = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_timestamp(&has_bits);
          timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 host_timestamp = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_host_timestamp(&has_bits);
          host_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 rd_bytes = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_rd_bytes(&has_bits);
          rd_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 wr_bytes = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_wr_bytes(&has_bits);
          wr_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_response_events::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_response.events)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 awlen = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_awlen(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &awlen_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 arlen = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_arlen(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &arlen_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 eventflags = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_eventflags(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &eventflags_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 timestamp = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_timestamp(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 host_timestamp = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_host_timestamp(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &host_timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rd_bytes = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_rd_bytes(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rd_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 wr_bytes = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_wr_bytes(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &wr_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_response.events)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_response.events)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_response_events::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 awlen = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->awlen(), output);
  }

  // optional uint32 arlen = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->arlen(), output);
  }

  // optional uint32 eventflags = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->eventflags(), output);
  }

  // optional uint32 timestamp = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->timestamp(), output);
  }

  // optional uint64 host_timestamp = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->host_timestamp(), output);
  }

  // optional uint32 rd_bytes = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(6, this->rd_bytes(), output);
  }

  // optional uint32 wr_bytes = 7;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(7, this->wr_bytes(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_response.events)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_response_events::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 awlen = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->awlen(), target);
  }

  // optional uint32 arlen = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->arlen(), target);
  }

  // optional uint32 eventflags = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->eventflags(), target);
  }

  // optional uint32 timestamp = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->timestamp(), target);
  }

  // optional uint64 host_timestamp = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->host_timestamp(), target);
  }

  // optional uint32 rd_bytes = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->rd_bytes(), target);
  }

  // optional uint32 wr_bytes = 7;
  if (cached_has_bits & 0x00000040u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->wr_bytes(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_response.events)
  return target;
}

size_t xclPerfMonReadTrace_response_events::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_response.events)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // optional uint32 awlen = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->awlen());
    }

    // optional uint32 arlen = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->arlen());
    }

    // optional uint32 eventflags = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->eventflags());
    }

    // optional uint32 timestamp = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->timestamp());
    }

    // optional uint64 host_timestamp = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->host_timestamp());
    }

    // optional uint32 rd_bytes = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->rd_bytes());
    }

    // optional uint32 wr_bytes = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->wr_bytes());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_response_events::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_response.events)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_response_events* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_response_events>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_response.events)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_response.events)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_response_events::MergeFrom(const xclPerfMonReadTrace_response_events& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_response.events)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      awlen_ = from.awlen_;
    }
    if (cached_has_bits & 0x00000002u) {
      arlen_ = from.arlen_;
    }
    if (cached_has_bits & 0x00000004u) {
      eventflags_ = from.eventflags_;
    }
    if (cached_has_bits & 0x00000008u) {
      timestamp_ = from.timestamp_;
    }
    if (cached_has_bits & 0x00000010u) {
      host_timestamp_ = from.host_timestamp_;
    }
    if (cached_has_bits & 0x00000020u) {
      rd_bytes_ = from.rd_bytes_;
    }
    if (cached_has_bits & 0x00000040u) {
      wr_bytes_ = from.wr_bytes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadTrace_response_events::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_response.events)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_response_events::InternalSwap(xclPerfMonReadTrace_response_events* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(awlen_, other->awlen_);
  swap(arlen_, other->arlen_);
  swap(eventflags_, other->eventflags_);
  swap(timestamp_, other->timestamp_);
  swap(host_timestamp_, other->host_timestamp_);
  swap(rd_bytes_, other->rd_bytes_);
  swap(wr_bytes_, other->wr_bytes_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_response_events::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_response::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_response>()._has_bits_);
};

xclPerfMonReadTrace_response::xclPerfMonReadTrace_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_response)
}
xclPerfMonReadTrace_response::xclPerfMonReadTrace_response(const xclPerfMonReadTrace_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      output_data_(from.output_data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_response)
}

void xclPerfMonReadTrace_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto.base);
}

xclPerfMonReadTrace_response::~xclPerfMonReadTrace_response() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_response)
  SharedDtor();
}

void xclPerfMonReadTrace_response::SharedDtor() {
}

void xclPerfMonReadTrace_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_response& xclPerfMonReadTrace_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  output_data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .xclPerfMonReadTrace_response.events output_data = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_output_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .xclPerfMonReadTrace_response.events output_data = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_output_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_response.events output_data = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->output_data_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      8,
      this->output_data(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_response.events output_data = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->output_data_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, this->output_data(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_response)
  return target;
}

size_t xclPerfMonReadTrace_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_response.events output_data = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->output_data_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->output_data(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_response)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_response::MergeFrom(const xclPerfMonReadTrace_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  output_data_.MergeFrom(from.output_data_);
}

void xclPerfMonReadTrace_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_response::InternalSwap(xclPerfMonReadTrace_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&output_data_)->InternalSwap(CastToBase(&other->output_data_));
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void ddr_mem_msg::InitAsDefaultInstance() {
}
class ddr_mem_msg::_Internal {
 public:
  using HasBits = decltype(std::declval<ddr_mem_msg>()._has_bits_);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_strb_data(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_fullsize(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

ddr_mem_msg::ddr_mem_msg()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ddr_mem_msg)
}
ddr_mem_msg::ddr_mem_msg(const ddr_mem_msg& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  strb_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_strb_data()) {
    strb_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.strb_data_);
  }
  ::memcpy(&size_, &from.size_,
    static_cast<size_t>(reinterpret_cast<char*>(&fullsize_) -
    reinterpret_cast<char*>(&size_)) + sizeof(fullsize_));
  // @@protoc_insertion_point(copy_constructor:ddr_mem_msg)
}

void ddr_mem_msg::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ddr_mem_msg_rpc_5fmessages_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  strb_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&fullsize_) -
      reinterpret_cast<char*>(&size_)) + sizeof(fullsize_));
}

ddr_mem_msg::~ddr_mem_msg() {
  // @@protoc_insertion_point(destructor:ddr_mem_msg)
  SharedDtor();
}

void ddr_mem_msg::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  strb_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ddr_mem_msg::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ddr_mem_msg& ddr_mem_msg::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ddr_mem_msg_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void ddr_mem_msg::Clear() {
// @@protoc_insertion_point(message_clear_start:ddr_mem_msg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      strb_data_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fullsize_) -
        reinterpret_cast<char*>(&size_)) + sizeof(fullsize_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ddr_mem_msg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required bytes data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes strb_data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_strb_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 fullsize = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_fullsize(&has_bits);
          fullsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ddr_mem_msg::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:ddr_mem_msg)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes data = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes strb_data = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_strb_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 fullsize = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_fullsize(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &fullsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ddr_mem_msg)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ddr_mem_msg)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void ddr_mem_msg::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ddr_mem_msg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes data = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->data(), output);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->size(), output);
  }

  // optional bytes strb_data = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->strb_data(), output);
  }

  // optional uint64 fullsize = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->fullsize(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:ddr_mem_msg)
}

::PROTOBUF_NAMESPACE_ID::uint8* ddr_mem_msg::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:ddr_mem_msg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes data = 1;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        1, this->data(), target);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->size(), target);
  }

  // optional bytes strb_data = 3;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        3, this->strb_data(), target);
  }

  // optional uint64 fullsize = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->fullsize(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:ddr_mem_msg)
  return target;
}

size_t ddr_mem_msg::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ddr_mem_msg)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required bytes data = 1;
  if (has_data()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->data());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000eu) {
    // optional bytes strb_data = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->strb_data());
    }

    // optional uint64 size = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

    // optional uint64 fullsize = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->fullsize());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ddr_mem_msg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:ddr_mem_msg)
  GOOGLE_DCHECK_NE(&from, this);
  const ddr_mem_msg* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ddr_mem_msg>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:ddr_mem_msg)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:ddr_mem_msg)
    MergeFrom(*source);
  }
}

void ddr_mem_msg::MergeFrom(const ddr_mem_msg& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ddr_mem_msg)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      strb_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.strb_data_);
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      fullsize_ = from.fullsize_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ddr_mem_msg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:ddr_mem_msg)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool ddr_mem_msg::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void ddr_mem_msg::InternalSwap(ddr_mem_msg* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  strb_data_.Swap(&other->strb_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(size_, other->size_);
  swap(fullsize_, other->fullsize_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ddr_mem_msg::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclGetDeviceTimestamp_call::InitAsDefaultInstance() {
}
class xclGetDeviceTimestamp_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclGetDeviceTimestamp_call>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclGetDeviceTimestamp_call::xclGetDeviceTimestamp_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclGetDeviceTimestamp_call)
}
xclGetDeviceTimestamp_call::xclGetDeviceTimestamp_call(const xclGetDeviceTimestamp_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclGetDeviceTimestamp_call)
}

void xclGetDeviceTimestamp_call::SharedCtor() {
  ack_ = false;
}

xclGetDeviceTimestamp_call::~xclGetDeviceTimestamp_call() {
  // @@protoc_insertion_point(destructor:xclGetDeviceTimestamp_call)
  SharedDtor();
}

void xclGetDeviceTimestamp_call::SharedDtor() {
}

void xclGetDeviceTimestamp_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclGetDeviceTimestamp_call& xclGetDeviceTimestamp_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclGetDeviceTimestamp_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclGetDeviceTimestamp_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclGetDeviceTimestamp_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclGetDeviceTimestamp_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclGetDeviceTimestamp_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclGetDeviceTimestamp_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclGetDeviceTimestamp_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclGetDeviceTimestamp_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclGetDeviceTimestamp_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclGetDeviceTimestamp_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclGetDeviceTimestamp_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclGetDeviceTimestamp_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclGetDeviceTimestamp_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclGetDeviceTimestamp_call)
  return target;
}

size_t xclGetDeviceTimestamp_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclGetDeviceTimestamp_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool ack = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclGetDeviceTimestamp_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclGetDeviceTimestamp_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclGetDeviceTimestamp_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclGetDeviceTimestamp_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclGetDeviceTimestamp_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclGetDeviceTimestamp_call)
    MergeFrom(*source);
  }
}

void xclGetDeviceTimestamp_call::MergeFrom(const xclGetDeviceTimestamp_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclGetDeviceTimestamp_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclGetDeviceTimestamp_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclGetDeviceTimestamp_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclGetDeviceTimestamp_call::InternalSwap(xclGetDeviceTimestamp_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclGetDeviceTimestamp_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclGetDeviceTimestamp_response::InitAsDefaultInstance() {
}
class xclGetDeviceTimestamp_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclGetDeviceTimestamp_response>()._has_bits_);
  static void set_has_device_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclGetDeviceTimestamp_response::xclGetDeviceTimestamp_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclGetDeviceTimestamp_response)
}
xclGetDeviceTimestamp_response::xclGetDeviceTimestamp_response(const xclGetDeviceTimestamp_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  device_timestamp_ = from.device_timestamp_;
  // @@protoc_insertion_point(copy_constructor:xclGetDeviceTimestamp_response)
}

void xclGetDeviceTimestamp_response::SharedCtor() {
  device_timestamp_ = PROTOBUF_ULONGLONG(0);
}

xclGetDeviceTimestamp_response::~xclGetDeviceTimestamp_response() {
  // @@protoc_insertion_point(destructor:xclGetDeviceTimestamp_response)
  SharedDtor();
}

void xclGetDeviceTimestamp_response::SharedDtor() {
}

void xclGetDeviceTimestamp_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclGetDeviceTimestamp_response& xclGetDeviceTimestamp_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclGetDeviceTimestamp_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclGetDeviceTimestamp_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclGetDeviceTimestamp_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  device_timestamp_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclGetDeviceTimestamp_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 device_timestamp = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_device_timestamp(&has_bits);
          device_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclGetDeviceTimestamp_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclGetDeviceTimestamp_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 device_timestamp = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_device_timestamp(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &device_timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclGetDeviceTimestamp_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclGetDeviceTimestamp_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclGetDeviceTimestamp_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclGetDeviceTimestamp_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 device_timestamp = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->device_timestamp(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclGetDeviceTimestamp_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclGetDeviceTimestamp_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclGetDeviceTimestamp_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 device_timestamp = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->device_timestamp(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclGetDeviceTimestamp_response)
  return target;
}

size_t xclGetDeviceTimestamp_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclGetDeviceTimestamp_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required uint64 device_timestamp = 1;
  if (has_device_timestamp()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->device_timestamp());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclGetDeviceTimestamp_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclGetDeviceTimestamp_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclGetDeviceTimestamp_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclGetDeviceTimestamp_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclGetDeviceTimestamp_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclGetDeviceTimestamp_response)
    MergeFrom(*source);
  }
}

void xclGetDeviceTimestamp_response::MergeFrom(const xclGetDeviceTimestamp_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclGetDeviceTimestamp_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_device_timestamp()) {
    set_device_timestamp(from.device_timestamp());
  }
}

void xclGetDeviceTimestamp_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclGetDeviceTimestamp_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclGetDeviceTimestamp_response::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclGetDeviceTimestamp_response::InternalSwap(xclGetDeviceTimestamp_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(device_timestamp_, other->device_timestamp_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclGetDeviceTimestamp_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadBusStatus_call::InitAsDefaultInstance() {
}
class xclReadBusStatus_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadBusStatus_call>()._has_bits_);
  static void set_has_slot_n(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclReadBusStatus_call::xclReadBusStatus_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadBusStatus_call)
}
xclReadBusStatus_call::xclReadBusStatus_call(const xclReadBusStatus_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slot_n_ = from.slot_n_;
  // @@protoc_insertion_point(copy_constructor:xclReadBusStatus_call)
}

void xclReadBusStatus_call::SharedCtor() {
  slot_n_ = 0;
}

xclReadBusStatus_call::~xclReadBusStatus_call() {
  // @@protoc_insertion_point(destructor:xclReadBusStatus_call)
  SharedDtor();
}

void xclReadBusStatus_call::SharedDtor() {
}

void xclReadBusStatus_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadBusStatus_call& xclReadBusStatus_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadBusStatus_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadBusStatus_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadBusStatus_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  slot_n_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadBusStatus_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 slot_n = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_slot_n(&has_bits);
          slot_n_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadBusStatus_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadBusStatus_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 slot_n = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_slot_n(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &slot_n_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadBusStatus_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadBusStatus_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadBusStatus_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadBusStatus_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 slot_n = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->slot_n(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadBusStatus_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadBusStatus_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadBusStatus_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 slot_n = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->slot_n(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadBusStatus_call)
  return target;
}

size_t xclReadBusStatus_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadBusStatus_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 slot_n = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->slot_n());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadBusStatus_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadBusStatus_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadBusStatus_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadBusStatus_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadBusStatus_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadBusStatus_call)
    MergeFrom(*source);
  }
}

void xclReadBusStatus_call::MergeFrom(const xclReadBusStatus_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadBusStatus_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_slot_n()) {
    set_slot_n(from.slot_n());
  }
}

void xclReadBusStatus_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadBusStatus_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclReadBusStatus_call::InternalSwap(xclReadBusStatus_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(slot_n_, other->slot_n_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadBusStatus_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadBusStatus_response::InitAsDefaultInstance() {
}
class xclReadBusStatus_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadBusStatus_response>()._has_bits_);
  static void set_has_uncomplete_rd_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_uncomplete_wr_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_idle_bus_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_uncomplete_rd_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_uncomplete_wr_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

xclReadBusStatus_response::xclReadBusStatus_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadBusStatus_response)
}
xclReadBusStatus_response::xclReadBusStatus_response(const xclReadBusStatus_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&uncomplete_rd_cycles_, &from.uncomplete_rd_cycles_,
    static_cast<size_t>(reinterpret_cast<char*>(&uncomplete_wr_id_) -
    reinterpret_cast<char*>(&uncomplete_rd_cycles_)) + sizeof(uncomplete_wr_id_));
  // @@protoc_insertion_point(copy_constructor:xclReadBusStatus_response)
}

void xclReadBusStatus_response::SharedCtor() {
  ::memset(&uncomplete_rd_cycles_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&uncomplete_wr_id_) -
      reinterpret_cast<char*>(&uncomplete_rd_cycles_)) + sizeof(uncomplete_wr_id_));
}

xclReadBusStatus_response::~xclReadBusStatus_response() {
  // @@protoc_insertion_point(destructor:xclReadBusStatus_response)
  SharedDtor();
}

void xclReadBusStatus_response::SharedDtor() {
}

void xclReadBusStatus_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadBusStatus_response& xclReadBusStatus_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadBusStatus_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadBusStatus_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadBusStatus_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&uncomplete_rd_cycles_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&uncomplete_wr_id_) -
        reinterpret_cast<char*>(&uncomplete_rd_cycles_)) + sizeof(uncomplete_wr_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadBusStatus_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 uncomplete_rd_cycles = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_uncomplete_rd_cycles(&has_bits);
          uncomplete_rd_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 uncomplete_wr_cycles = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_uncomplete_wr_cycles(&has_bits);
          uncomplete_wr_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 idle_bus_cycles = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_idle_bus_cycles(&has_bits);
          idle_bus_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 uncomplete_rd_id = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_uncomplete_rd_id(&has_bits);
          uncomplete_rd_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 uncomplete_wr_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_uncomplete_wr_id(&has_bits);
          uncomplete_wr_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadBusStatus_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadBusStatus_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 uncomplete_rd_cycles = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_uncomplete_rd_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &uncomplete_rd_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 uncomplete_wr_cycles = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_uncomplete_wr_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &uncomplete_wr_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 idle_bus_cycles = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_idle_bus_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &idle_bus_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 uncomplete_rd_id = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_uncomplete_rd_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &uncomplete_rd_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 uncomplete_wr_id = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_uncomplete_wr_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &uncomplete_wr_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadBusStatus_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadBusStatus_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadBusStatus_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadBusStatus_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 uncomplete_rd_cycles = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->uncomplete_rd_cycles(), output);
  }

  // optional uint64 uncomplete_wr_cycles = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->uncomplete_wr_cycles(), output);
  }

  // optional uint64 idle_bus_cycles = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->idle_bus_cycles(), output);
  }

  // optional uint64 uncomplete_rd_id = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->uncomplete_rd_id(), output);
  }

  // optional uint64 uncomplete_wr_id = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->uncomplete_wr_id(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadBusStatus_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadBusStatus_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadBusStatus_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 uncomplete_rd_cycles = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->uncomplete_rd_cycles(), target);
  }

  // optional uint64 uncomplete_wr_cycles = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->uncomplete_wr_cycles(), target);
  }

  // optional uint64 idle_bus_cycles = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->idle_bus_cycles(), target);
  }

  // optional uint64 uncomplete_rd_id = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->uncomplete_rd_id(), target);
  }

  // optional uint64 uncomplete_wr_id = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->uncomplete_wr_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadBusStatus_response)
  return target;
}

size_t xclReadBusStatus_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadBusStatus_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional uint64 uncomplete_rd_cycles = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->uncomplete_rd_cycles());
    }

    // optional uint64 uncomplete_wr_cycles = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->uncomplete_wr_cycles());
    }

    // optional uint64 idle_bus_cycles = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->idle_bus_cycles());
    }

    // optional uint64 uncomplete_rd_id = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->uncomplete_rd_id());
    }

    // optional uint64 uncomplete_wr_id = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->uncomplete_wr_id());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadBusStatus_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadBusStatus_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadBusStatus_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadBusStatus_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadBusStatus_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadBusStatus_response)
    MergeFrom(*source);
  }
}

void xclReadBusStatus_response::MergeFrom(const xclReadBusStatus_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadBusStatus_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      uncomplete_rd_cycles_ = from.uncomplete_rd_cycles_;
    }
    if (cached_has_bits & 0x00000002u) {
      uncomplete_wr_cycles_ = from.uncomplete_wr_cycles_;
    }
    if (cached_has_bits & 0x00000004u) {
      idle_bus_cycles_ = from.idle_bus_cycles_;
    }
    if (cached_has_bits & 0x00000008u) {
      uncomplete_rd_id_ = from.uncomplete_rd_id_;
    }
    if (cached_has_bits & 0x00000010u) {
      uncomplete_wr_id_ = from.uncomplete_wr_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadBusStatus_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadBusStatus_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclReadBusStatus_response::InternalSwap(xclReadBusStatus_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(uncomplete_rd_cycles_, other->uncomplete_rd_cycles_);
  swap(uncomplete_wr_cycles_, other->uncomplete_wr_cycles_);
  swap(idle_bus_cycles_, other->idle_bus_cycles_);
  swap(uncomplete_rd_id_, other->uncomplete_rd_id_);
  swap(uncomplete_wr_id_, other->uncomplete_wr_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadBusStatus_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclGetDebugMessages_call::InitAsDefaultInstance() {
}
class xclGetDebugMessages_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclGetDebugMessages_call>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_force(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclGetDebugMessages_call::xclGetDebugMessages_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclGetDebugMessages_call)
}
xclGetDebugMessages_call::xclGetDebugMessages_call(const xclGetDebugMessages_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ack_, &from.ack_,
    static_cast<size_t>(reinterpret_cast<char*>(&force_) -
    reinterpret_cast<char*>(&ack_)) + sizeof(force_));
  // @@protoc_insertion_point(copy_constructor:xclGetDebugMessages_call)
}

void xclGetDebugMessages_call::SharedCtor() {
  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&force_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(force_));
}

xclGetDebugMessages_call::~xclGetDebugMessages_call() {
  // @@protoc_insertion_point(destructor:xclGetDebugMessages_call)
  SharedDtor();
}

void xclGetDebugMessages_call::SharedDtor() {
}

void xclGetDebugMessages_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclGetDebugMessages_call& xclGetDebugMessages_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclGetDebugMessages_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclGetDebugMessages_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclGetDebugMessages_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&ack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&force_) -
      reinterpret_cast<char*>(&ack_)) + sizeof(force_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclGetDebugMessages_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool force = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_force(&has_bits);
          force_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclGetDebugMessages_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclGetDebugMessages_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_force(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclGetDebugMessages_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclGetDebugMessages_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclGetDebugMessages_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclGetDebugMessages_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  // optional bool force = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->force(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclGetDebugMessages_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclGetDebugMessages_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclGetDebugMessages_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  // optional bool force = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->force(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclGetDebugMessages_call)
  return target;
}

size_t xclGetDebugMessages_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclGetDebugMessages_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bool ack = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 1;
    }

    // optional bool force = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclGetDebugMessages_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclGetDebugMessages_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclGetDebugMessages_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclGetDebugMessages_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclGetDebugMessages_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclGetDebugMessages_call)
    MergeFrom(*source);
  }
}

void xclGetDebugMessages_call::MergeFrom(const xclGetDebugMessages_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclGetDebugMessages_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ack_ = from.ack_;
    }
    if (cached_has_bits & 0x00000002u) {
      force_ = from.force_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclGetDebugMessages_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclGetDebugMessages_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclGetDebugMessages_call::InternalSwap(xclGetDebugMessages_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
  swap(force_, other->force_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclGetDebugMessages_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclGetDebugMessages_response::InitAsDefaultInstance() {
}
class xclGetDebugMessages_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclGetDebugMessages_response>()._has_bits_);
  static void set_has_display_msgs(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_log_msgs(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_stop_msgs(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclGetDebugMessages_response::xclGetDebugMessages_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclGetDebugMessages_response)
}
xclGetDebugMessages_response::xclGetDebugMessages_response(const xclGetDebugMessages_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  display_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_display_msgs()) {
    display_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.display_msgs_);
  }
  log_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_log_msgs()) {
    log_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.log_msgs_);
  }
  stop_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_stop_msgs()) {
    stop_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.stop_msgs_);
  }
  // @@protoc_insertion_point(copy_constructor:xclGetDebugMessages_response)
}

void xclGetDebugMessages_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto.base);
  display_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  log_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  stop_msgs_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

xclGetDebugMessages_response::~xclGetDebugMessages_response() {
  // @@protoc_insertion_point(destructor:xclGetDebugMessages_response)
  SharedDtor();
}

void xclGetDebugMessages_response::SharedDtor() {
  display_msgs_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  log_msgs_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  stop_msgs_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclGetDebugMessages_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclGetDebugMessages_response& xclGetDebugMessages_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclGetDebugMessages_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclGetDebugMessages_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclGetDebugMessages_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      display_msgs_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      log_msgs_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      stop_msgs_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclGetDebugMessages_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bytes display_msgs = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_display_msgs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes log_msgs = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_log_msgs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes stop_msgs = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_stop_msgs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclGetDebugMessages_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclGetDebugMessages_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes display_msgs = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_display_msgs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes log_msgs = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_log_msgs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes stop_msgs = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_stop_msgs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclGetDebugMessages_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclGetDebugMessages_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclGetDebugMessages_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclGetDebugMessages_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes display_msgs = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->display_msgs(), output);
  }

  // optional bytes log_msgs = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->log_msgs(), output);
  }

  // optional bytes stop_msgs = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->stop_msgs(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclGetDebugMessages_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclGetDebugMessages_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclGetDebugMessages_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes display_msgs = 1;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        1, this->display_msgs(), target);
  }

  // optional bytes log_msgs = 2;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->log_msgs(), target);
  }

  // optional bytes stop_msgs = 3;
  if (cached_has_bits & 0x00000004u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        3, this->stop_msgs(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclGetDebugMessages_response)
  return target;
}

size_t xclGetDebugMessages_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclGetDebugMessages_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional bytes display_msgs = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->display_msgs());
    }

    // optional bytes log_msgs = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->log_msgs());
    }

    // optional bytes stop_msgs = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->stop_msgs());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclGetDebugMessages_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclGetDebugMessages_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclGetDebugMessages_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclGetDebugMessages_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclGetDebugMessages_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclGetDebugMessages_response)
    MergeFrom(*source);
  }
}

void xclGetDebugMessages_response::MergeFrom(const xclGetDebugMessages_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclGetDebugMessages_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      display_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.display_msgs_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      log_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.log_msgs_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      stop_msgs_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.stop_msgs_);
    }
  }
}

void xclGetDebugMessages_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclGetDebugMessages_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclGetDebugMessages_response::InternalSwap(xclGetDebugMessages_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  display_msgs_.Swap(&other->display_msgs_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  log_msgs_.Swap(&other->log_msgs_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  stop_msgs_.Swap(&other->stop_msgs_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata xclGetDebugMessages_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclImportBO_call::InitAsDefaultInstance() {
}
class xclImportBO_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclImportBO_call>()._has_bits_);
  static void set_has_dst_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_offset(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclImportBO_call::xclImportBO_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclImportBO_call)
}
xclImportBO_call::xclImportBO_call(const xclImportBO_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dst_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dst_filename()) {
    dst_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dst_filename_);
  }
  ::memcpy(&offset_, &from.offset_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&offset_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:xclImportBO_call)
}

void xclImportBO_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclImportBO_call_rpc_5fmessages_2eproto.base);
  dst_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&offset_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&offset_)) + sizeof(size_));
}

xclImportBO_call::~xclImportBO_call() {
  // @@protoc_insertion_point(destructor:xclImportBO_call)
  SharedDtor();
}

void xclImportBO_call::SharedDtor() {
  dst_filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclImportBO_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclImportBO_call& xclImportBO_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclImportBO_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclImportBO_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclImportBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dst_filename_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&offset_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&offset_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclImportBO_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string dst_filename = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_dst_filename(), ptr, ctx, "xclImportBO_call.dst_filename");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 offset = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_offset(&has_bits);
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclImportBO_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclImportBO_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string dst_filename = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_dst_filename()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclImportBO_call.dst_filename");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 offset = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_offset(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclImportBO_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclImportBO_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclImportBO_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclImportBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string dst_filename = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclImportBO_call.dst_filename");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->dst_filename(), output);
  }

  // optional uint64 offset = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->offset(), output);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclImportBO_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclImportBO_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclImportBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string dst_filename = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclImportBO_call.dst_filename");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->dst_filename(), target);
  }

  // optional uint64 offset = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->offset(), target);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclImportBO_call)
  return target;
}

size_t xclImportBO_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclImportBO_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string dst_filename = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->dst_filename());
    }

    // optional uint64 offset = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->offset());
    }

    // optional uint64 size = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclImportBO_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclImportBO_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclImportBO_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclImportBO_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclImportBO_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclImportBO_call)
    MergeFrom(*source);
  }
}

void xclImportBO_call::MergeFrom(const xclImportBO_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclImportBO_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dst_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dst_filename_);
    }
    if (cached_has_bits & 0x00000002u) {
      offset_ = from.offset_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclImportBO_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclImportBO_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclImportBO_call::InternalSwap(xclImportBO_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dst_filename_.Swap(&other->dst_filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(offset_, other->offset_);
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclImportBO_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclImportBO_response::InitAsDefaultInstance() {
}
class xclImportBO_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclImportBO_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclImportBO_response::xclImportBO_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclImportBO_response)
}
xclImportBO_response::xclImportBO_response(const xclImportBO_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclImportBO_response)
}

void xclImportBO_response::SharedCtor() {
  ack_ = false;
}

xclImportBO_response::~xclImportBO_response() {
  // @@protoc_insertion_point(destructor:xclImportBO_response)
  SharedDtor();
}

void xclImportBO_response::SharedDtor() {
}

void xclImportBO_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclImportBO_response& xclImportBO_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclImportBO_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclImportBO_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclImportBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclImportBO_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclImportBO_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclImportBO_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclImportBO_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclImportBO_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclImportBO_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclImportBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclImportBO_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclImportBO_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclImportBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclImportBO_response)
  return target;
}

size_t xclImportBO_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclImportBO_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool ack = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclImportBO_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclImportBO_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclImportBO_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclImportBO_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclImportBO_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclImportBO_response)
    MergeFrom(*source);
  }
}

void xclImportBO_response::MergeFrom(const xclImportBO_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclImportBO_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclImportBO_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclImportBO_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclImportBO_response::InternalSwap(xclImportBO_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclImportBO_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBO_call::InitAsDefaultInstance() {
}
class xclCopyBO_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBO_call>()._has_bits_);
  static void set_has_src_handle(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_dst_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_src_offset(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_dst_offset(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

xclCopyBO_call::xclCopyBO_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBO_call)
}
xclCopyBO_call::xclCopyBO_call(const xclCopyBO_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dst_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dst_filename()) {
    dst_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dst_filename_);
  }
  ::memcpy(&src_handle_, &from.src_handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&dst_offset_) -
    reinterpret_cast<char*>(&src_handle_)) + sizeof(dst_offset_));
  // @@protoc_insertion_point(copy_constructor:xclCopyBO_call)
}

void xclCopyBO_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclCopyBO_call_rpc_5fmessages_2eproto.base);
  dst_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&src_handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&dst_offset_) -
      reinterpret_cast<char*>(&src_handle_)) + sizeof(dst_offset_));
}

xclCopyBO_call::~xclCopyBO_call() {
  // @@protoc_insertion_point(destructor:xclCopyBO_call)
  SharedDtor();
}

void xclCopyBO_call::SharedDtor() {
  dst_filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclCopyBO_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBO_call& xclCopyBO_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBO_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBO_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dst_filename_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000001eu) {
    ::memset(&src_handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&dst_offset_) -
        reinterpret_cast<char*>(&src_handle_)) + sizeof(dst_offset_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBO_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 src_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_src_handle(&has_bits);
          src_handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string dst_filename = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_dst_filename(), ptr, ctx, "xclCopyBO_call.dst_filename");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 src_offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_src_offset(&has_bits);
          src_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 dst_offset = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_dst_offset(&has_bits);
          dst_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBO_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBO_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 src_handle = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_src_handle(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &src_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string dst_filename = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_dst_filename()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclCopyBO_call.dst_filename");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 src_offset = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_src_offset(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &src_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 dst_offset = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_dst_offset(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &dst_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBO_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBO_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBO_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 src_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->src_handle(), output);
  }

  // optional string dst_filename = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclCopyBO_call.dst_filename");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->dst_filename(), output);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->size(), output);
  }

  // optional uint64 src_offset = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->src_offset(), output);
  }

  // optional uint64 dst_offset = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->dst_offset(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBO_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBO_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBO_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 src_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->src_handle(), target);
  }

  // optional string dst_filename = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dst_filename().data(), static_cast<int>(this->dst_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclCopyBO_call.dst_filename");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->dst_filename(), target);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->size(), target);
  }

  // optional uint64 src_offset = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->src_offset(), target);
  }

  // optional uint64 dst_offset = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->dst_offset(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBO_call)
  return target;
}

size_t xclCopyBO_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBO_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string dst_filename = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->dst_filename());
    }

    // optional uint64 src_handle = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->src_handle());
    }

    // optional uint64 size = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

    // optional uint64 src_offset = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->src_offset());
    }

    // optional uint64 dst_offset = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->dst_offset());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBO_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBO_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBO_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBO_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBO_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBO_call)
    MergeFrom(*source);
  }
}

void xclCopyBO_call::MergeFrom(const xclCopyBO_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBO_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dst_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dst_filename_);
    }
    if (cached_has_bits & 0x00000002u) {
      src_handle_ = from.src_handle_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      src_offset_ = from.src_offset_;
    }
    if (cached_has_bits & 0x00000010u) {
      dst_offset_ = from.dst_offset_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclCopyBO_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBO_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclCopyBO_call::InternalSwap(xclCopyBO_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dst_filename_.Swap(&other->dst_filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(src_handle_, other->src_handle_);
  swap(size_, other->size_);
  swap(src_offset_, other->src_offset_);
  swap(dst_offset_, other->dst_offset_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBO_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCopyBO_response::InitAsDefaultInstance() {
}
class xclCopyBO_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCopyBO_response>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclCopyBO_response::xclCopyBO_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCopyBO_response)
}
xclCopyBO_response::xclCopyBO_response(const xclCopyBO_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclCopyBO_response)
}

void xclCopyBO_response::SharedCtor() {
  ack_ = false;
}

xclCopyBO_response::~xclCopyBO_response() {
  // @@protoc_insertion_point(destructor:xclCopyBO_response)
  SharedDtor();
}

void xclCopyBO_response::SharedDtor() {
}

void xclCopyBO_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCopyBO_response& xclCopyBO_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCopyBO_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCopyBO_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCopyBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCopyBO_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCopyBO_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCopyBO_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCopyBO_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCopyBO_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCopyBO_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCopyBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCopyBO_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCopyBO_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCopyBO_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCopyBO_response)
  return target;
}

size_t xclCopyBO_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCopyBO_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool ack = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCopyBO_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCopyBO_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCopyBO_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCopyBO_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCopyBO_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCopyBO_response)
    MergeFrom(*source);
  }
}

void xclCopyBO_response::MergeFrom(const xclCopyBO_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCopyBO_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_ack()) {
    set_ack(from.ack());
  }
}

void xclCopyBO_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCopyBO_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclCopyBO_response::InternalSwap(xclCopyBO_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCopyBO_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCreateQueue_call::InitAsDefaultInstance() {
}
class xclCreateQueue_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCreateQueue_call>()._has_bits_);
  static void set_has_write(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_route(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_flow(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_qsize(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_desc_size(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
};

xclCreateQueue_call::xclCreateQueue_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCreateQueue_call)
}
xclCreateQueue_call::xclCreateQueue_call(const xclCreateQueue_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&write_, &from.write_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&write_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:xclCreateQueue_call)
}

void xclCreateQueue_call::SharedCtor() {
  ::memset(&write_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&flags_) -
      reinterpret_cast<char*>(&write_)) + sizeof(flags_));
}

xclCreateQueue_call::~xclCreateQueue_call() {
  // @@protoc_insertion_point(destructor:xclCreateQueue_call)
  SharedDtor();
}

void xclCreateQueue_call::SharedDtor() {
}

void xclCreateQueue_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCreateQueue_call& xclCreateQueue_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCreateQueue_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCreateQueue_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCreateQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&write_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&write_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCreateQueue_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool write = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_write(&has_bits);
          write_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_type(&has_bits);
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 state = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_state(&has_bits);
          state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 route = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_route(&has_bits);
          route_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 flow = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_flow(&has_bits);
          flow_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 qsize = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_qsize(&has_bits);
          qsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 desc_size = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_desc_size(&has_bits);
          desc_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 flags = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCreateQueue_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCreateQueue_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool write = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_write(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &write_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 state = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_state(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &state_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 route = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_route(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &route_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 flow = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_flow(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &flow_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 qsize = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_qsize(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &qsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 desc_size = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_desc_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &desc_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 flags = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) {
          _Internal::set_has_flags(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &flags_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCreateQueue_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCreateQueue_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCreateQueue_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCreateQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool write = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->write(), output);
  }

  // optional uint32 type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->type(), output);
  }

  // optional uint32 state = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->state(), output);
  }

  // optional uint32 route = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->route(), output);
  }

  // optional uint64 flow = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->flow(), output);
  }

  // optional uint32 qsize = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(6, this->qsize(), output);
  }

  // optional uint32 desc_size = 7;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(7, this->desc_size(), output);
  }

  // optional uint64 flags = 8;
  if (cached_has_bits & 0x00000080u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(8, this->flags(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCreateQueue_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCreateQueue_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCreateQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool write = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->write(), target);
  }

  // optional uint32 type = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->type(), target);
  }

  // optional uint32 state = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->state(), target);
  }

  // optional uint32 route = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->route(), target);
  }

  // optional uint64 flow = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->flow(), target);
  }

  // optional uint32 qsize = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->qsize(), target);
  }

  // optional uint32 desc_size = 7;
  if (cached_has_bits & 0x00000040u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->desc_size(), target);
  }

  // optional uint64 flags = 8;
  if (cached_has_bits & 0x00000080u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->flags(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCreateQueue_call)
  return target;
}

size_t xclCreateQueue_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCreateQueue_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional bool write = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 1;
    }

    // optional uint32 type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->type());
    }

    // optional uint32 state = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->state());
    }

    // optional uint32 route = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->route());
    }

    // optional uint64 flow = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->flow());
    }

    // optional uint32 qsize = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->qsize());
    }

    // optional uint32 desc_size = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->desc_size());
    }

    // optional uint64 flags = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->flags());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCreateQueue_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCreateQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCreateQueue_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCreateQueue_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCreateQueue_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCreateQueue_call)
    MergeFrom(*source);
  }
}

void xclCreateQueue_call::MergeFrom(const xclCreateQueue_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCreateQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      write_ = from.write_;
    }
    if (cached_has_bits & 0x00000002u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000004u) {
      state_ = from.state_;
    }
    if (cached_has_bits & 0x00000008u) {
      route_ = from.route_;
    }
    if (cached_has_bits & 0x00000010u) {
      flow_ = from.flow_;
    }
    if (cached_has_bits & 0x00000020u) {
      qsize_ = from.qsize_;
    }
    if (cached_has_bits & 0x00000040u) {
      desc_size_ = from.desc_size_;
    }
    if (cached_has_bits & 0x00000080u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclCreateQueue_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCreateQueue_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclCreateQueue_call::InternalSwap(xclCreateQueue_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(write_, other->write_);
  swap(type_, other->type_);
  swap(state_, other->state_);
  swap(route_, other->route_);
  swap(flow_, other->flow_);
  swap(qsize_, other->qsize_);
  swap(desc_size_, other->desc_size_);
  swap(flags_, other->flags_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCreateQueue_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclCreateQueue_response::InitAsDefaultInstance() {
}
class xclCreateQueue_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclCreateQueue_response>()._has_bits_);
  static void set_has_q_handle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclCreateQueue_response::xclCreateQueue_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclCreateQueue_response)
}
xclCreateQueue_response::xclCreateQueue_response(const xclCreateQueue_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  q_handle_ = from.q_handle_;
  // @@protoc_insertion_point(copy_constructor:xclCreateQueue_response)
}

void xclCreateQueue_response::SharedCtor() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
}

xclCreateQueue_response::~xclCreateQueue_response() {
  // @@protoc_insertion_point(destructor:xclCreateQueue_response)
  SharedDtor();
}

void xclCreateQueue_response::SharedDtor() {
}

void xclCreateQueue_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclCreateQueue_response& xclCreateQueue_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclCreateQueue_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclCreateQueue_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclCreateQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclCreateQueue_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 q_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_q_handle(&has_bits);
          q_handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclCreateQueue_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclCreateQueue_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 q_handle = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_q_handle(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &q_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclCreateQueue_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclCreateQueue_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclCreateQueue_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclCreateQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->q_handle(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclCreateQueue_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclCreateQueue_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclCreateQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->q_handle(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclCreateQueue_response)
  return target;
}

size_t xclCreateQueue_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclCreateQueue_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 q_handle = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->q_handle());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclCreateQueue_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclCreateQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclCreateQueue_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclCreateQueue_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclCreateQueue_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclCreateQueue_response)
    MergeFrom(*source);
  }
}

void xclCreateQueue_response::MergeFrom(const xclCreateQueue_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclCreateQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_q_handle()) {
    set_q_handle(from.q_handle());
  }
}

void xclCreateQueue_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclCreateQueue_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclCreateQueue_response::InternalSwap(xclCreateQueue_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(q_handle_, other->q_handle_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclCreateQueue_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteQueue_call::InitAsDefaultInstance() {
}
class xclWriteQueue_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteQueue_call>()._has_bits_);
  static void set_has_q_handle(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_src(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_req(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_nonblocking(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_eot(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclWriteQueue_call::xclWriteQueue_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteQueue_call)
}
xclWriteQueue_call::xclWriteQueue_call(const xclWriteQueue_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_src()) {
    src_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.src_);
  }
  ::memcpy(&q_handle_, &from.q_handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&eot_) -
    reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
  // @@protoc_insertion_point(copy_constructor:xclWriteQueue_call)
}

void xclWriteQueue_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclWriteQueue_call_rpc_5fmessages_2eproto.base);
  src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&q_handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&eot_) -
      reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
}

xclWriteQueue_call::~xclWriteQueue_call() {
  // @@protoc_insertion_point(destructor:xclWriteQueue_call)
  SharedDtor();
}

void xclWriteQueue_call::SharedDtor() {
  src_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclWriteQueue_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteQueue_call& xclWriteQueue_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteQueue_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteQueue_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    src_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::memset(&q_handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&eot_) -
        reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteQueue_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 q_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_q_handle(&has_bits);
          q_handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes src = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_src(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 req = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_req(&has_bits);
          req_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool nonblocking = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_nonblocking(&has_bits);
          nonblocking_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool eot = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_eot(&has_bits);
          eot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteQueue_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteQueue_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 q_handle = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_q_handle(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &q_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes src = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_src()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 req = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_req(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &req_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool nonblocking = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_nonblocking(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &nonblocking_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool eot = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_eot(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &eot_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteQueue_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteQueue_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteQueue_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->q_handle(), output);
  }

  // optional bytes src = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->src(), output);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->size(), output);
  }

  // optional uint64 req = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->req(), output);
  }

  // optional bool nonblocking = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(5, this->nonblocking(), output);
  }

  // optional bool eot = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->eot(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteQueue_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteQueue_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->q_handle(), target);
  }

  // optional bytes src = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->src(), target);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->size(), target);
  }

  // optional uint64 req = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->req(), target);
  }

  // optional bool nonblocking = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->nonblocking(), target);
  }

  // optional bool eot = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->eot(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteQueue_call)
  return target;
}

size_t xclWriteQueue_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteQueue_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional bytes src = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->src());
    }

    // optional uint64 q_handle = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->q_handle());
    }

    // optional uint64 size = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

    // optional uint64 req = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->req());
    }

    // optional bool nonblocking = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool eot = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteQueue_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteQueue_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteQueue_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteQueue_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteQueue_call)
    MergeFrom(*source);
  }
}

void xclWriteQueue_call::MergeFrom(const xclWriteQueue_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      src_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.src_);
    }
    if (cached_has_bits & 0x00000002u) {
      q_handle_ = from.q_handle_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      req_ = from.req_;
    }
    if (cached_has_bits & 0x00000010u) {
      nonblocking_ = from.nonblocking_;
    }
    if (cached_has_bits & 0x00000020u) {
      eot_ = from.eot_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclWriteQueue_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteQueue_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclWriteQueue_call::InternalSwap(xclWriteQueue_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  src_.Swap(&other->src_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(q_handle_, other->q_handle_);
  swap(size_, other->size_);
  swap(req_, other->req_);
  swap(nonblocking_, other->nonblocking_);
  swap(eot_, other->eot_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteQueue_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclWriteQueue_response::InitAsDefaultInstance() {
}
class xclWriteQueue_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclWriteQueue_response>()._has_bits_);
  static void set_has_written_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclWriteQueue_response::xclWriteQueue_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclWriteQueue_response)
}
xclWriteQueue_response::xclWriteQueue_response(const xclWriteQueue_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  written_size_ = from.written_size_;
  // @@protoc_insertion_point(copy_constructor:xclWriteQueue_response)
}

void xclWriteQueue_response::SharedCtor() {
  written_size_ = PROTOBUF_ULONGLONG(0);
}

xclWriteQueue_response::~xclWriteQueue_response() {
  // @@protoc_insertion_point(destructor:xclWriteQueue_response)
  SharedDtor();
}

void xclWriteQueue_response::SharedDtor() {
}

void xclWriteQueue_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclWriteQueue_response& xclWriteQueue_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclWriteQueue_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclWriteQueue_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclWriteQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  written_size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclWriteQueue_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 written_size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_written_size(&has_bits);
          written_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclWriteQueue_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclWriteQueue_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 written_size = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_written_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &written_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclWriteQueue_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclWriteQueue_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclWriteQueue_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclWriteQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 written_size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->written_size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclWriteQueue_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclWriteQueue_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclWriteQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 written_size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->written_size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclWriteQueue_response)
  return target;
}

size_t xclWriteQueue_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclWriteQueue_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 written_size = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->written_size());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclWriteQueue_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclWriteQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclWriteQueue_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclWriteQueue_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclWriteQueue_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclWriteQueue_response)
    MergeFrom(*source);
  }
}

void xclWriteQueue_response::MergeFrom(const xclWriteQueue_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclWriteQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_written_size()) {
    set_written_size(from.written_size());
  }
}

void xclWriteQueue_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclWriteQueue_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclWriteQueue_response::InternalSwap(xclWriteQueue_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(written_size_, other->written_size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclWriteQueue_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadQueue_call::InitAsDefaultInstance() {
}
class xclReadQueue_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadQueue_call>()._has_bits_);
  static void set_has_q_handle(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_req(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_nonblocking(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_eot(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

xclReadQueue_call::xclReadQueue_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadQueue_call)
}
xclReadQueue_call::xclReadQueue_call(const xclReadQueue_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dest()) {
    dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
  }
  ::memcpy(&q_handle_, &from.q_handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&eot_) -
    reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
  // @@protoc_insertion_point(copy_constructor:xclReadQueue_call)
}

void xclReadQueue_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadQueue_call_rpc_5fmessages_2eproto.base);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&q_handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&eot_) -
      reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
}

xclReadQueue_call::~xclReadQueue_call() {
  // @@protoc_insertion_point(destructor:xclReadQueue_call)
  SharedDtor();
}

void xclReadQueue_call::SharedDtor() {
  dest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadQueue_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadQueue_call& xclReadQueue_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadQueue_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadQueue_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dest_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::memset(&q_handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&eot_) -
        reinterpret_cast<char*>(&q_handle_)) + sizeof(eot_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadQueue_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 q_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_q_handle(&has_bits);
          q_handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes dest = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dest(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 req = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_req(&has_bits);
          req_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool nonblocking = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_nonblocking(&has_bits);
          nonblocking_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool eot = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_eot(&has_bits);
          eot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadQueue_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadQueue_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 q_handle = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_q_handle(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &q_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes dest = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 req = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_req(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &req_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool nonblocking = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_nonblocking(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &nonblocking_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool eot = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_eot(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &eot_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadQueue_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadQueue_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadQueue_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->q_handle(), output);
  }

  // optional bytes dest = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->dest(), output);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->size(), output);
  }

  // optional uint64 req = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->req(), output);
  }

  // optional bool nonblocking = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(5, this->nonblocking(), output);
  }

  // optional bool eot = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->eot(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadQueue_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadQueue_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->q_handle(), target);
  }

  // optional bytes dest = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        2, this->dest(), target);
  }

  // optional uint64 size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->size(), target);
  }

  // optional uint64 req = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->req(), target);
  }

  // optional bool nonblocking = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->nonblocking(), target);
  }

  // optional bool eot = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->eot(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadQueue_call)
  return target;
}

size_t xclReadQueue_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadQueue_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional bytes dest = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->dest());
    }

    // optional uint64 q_handle = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->q_handle());
    }

    // optional uint64 size = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

    // optional uint64 req = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->req());
    }

    // optional bool nonblocking = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool eot = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadQueue_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadQueue_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadQueue_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadQueue_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadQueue_call)
    MergeFrom(*source);
  }
}

void xclReadQueue_call::MergeFrom(const xclReadQueue_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
    }
    if (cached_has_bits & 0x00000002u) {
      q_handle_ = from.q_handle_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      req_ = from.req_;
    }
    if (cached_has_bits & 0x00000010u) {
      nonblocking_ = from.nonblocking_;
    }
    if (cached_has_bits & 0x00000020u) {
      eot_ = from.eot_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadQueue_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadQueue_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclReadQueue_call::InternalSwap(xclReadQueue_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dest_.Swap(&other->dest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(q_handle_, other->q_handle_);
  swap(size_, other->size_);
  swap(req_, other->req_);
  swap(nonblocking_, other->nonblocking_);
  swap(eot_, other->eot_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadQueue_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclReadQueue_response::InitAsDefaultInstance() {
}
class xclReadQueue_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclReadQueue_response>()._has_bits_);
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclReadQueue_response::xclReadQueue_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclReadQueue_response)
}
xclReadQueue_response::xclReadQueue_response(const xclReadQueue_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dest()) {
    dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
  }
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:xclReadQueue_response)
}

void xclReadQueue_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclReadQueue_response_rpc_5fmessages_2eproto.base);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  size_ = PROTOBUF_ULONGLONG(0);
}

xclReadQueue_response::~xclReadQueue_response() {
  // @@protoc_insertion_point(destructor:xclReadQueue_response)
  SharedDtor();
}

void xclReadQueue_response::SharedDtor() {
  dest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclReadQueue_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclReadQueue_response& xclReadQueue_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclReadQueue_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclReadQueue_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclReadQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dest_.ClearNonDefaultToEmptyNoArena();
  }
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclReadQueue_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bytes dest = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dest(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclReadQueue_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclReadQueue_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes dest = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclReadQueue_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclReadQueue_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclReadQueue_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclReadQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes dest = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->dest(), output);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclReadQueue_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclReadQueue_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclReadQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes dest = 1;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        1, this->dest(), target);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclReadQueue_response)
  return target;
}

size_t xclReadQueue_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclReadQueue_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes dest = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->dest());
    }

    // optional uint64 size = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclReadQueue_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclReadQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclReadQueue_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclReadQueue_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclReadQueue_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclReadQueue_response)
    MergeFrom(*source);
  }
}

void xclReadQueue_response::MergeFrom(const xclReadQueue_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclReadQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
    }
    if (cached_has_bits & 0x00000002u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclReadQueue_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclReadQueue_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclReadQueue_response::InternalSwap(xclReadQueue_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dest_.Swap(&other->dest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclReadQueue_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPollCompletion_call::InitAsDefaultInstance() {
}
class xclPollCompletion_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPollCompletion_call>()._has_bits_);
  static void set_has_req(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclPollCompletion_call::xclPollCompletion_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPollCompletion_call)
}
xclPollCompletion_call::xclPollCompletion_call(const xclPollCompletion_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  req_ = from.req_;
  // @@protoc_insertion_point(copy_constructor:xclPollCompletion_call)
}

void xclPollCompletion_call::SharedCtor() {
  req_ = PROTOBUF_ULONGLONG(0);
}

xclPollCompletion_call::~xclPollCompletion_call() {
  // @@protoc_insertion_point(destructor:xclPollCompletion_call)
  SharedDtor();
}

void xclPollCompletion_call::SharedDtor() {
}

void xclPollCompletion_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPollCompletion_call& xclPollCompletion_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPollCompletion_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPollCompletion_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPollCompletion_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  req_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPollCompletion_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 req = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_req(&has_bits);
          req_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPollCompletion_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPollCompletion_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 req = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_req(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &req_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPollCompletion_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPollCompletion_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPollCompletion_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPollCompletion_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 req = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->req(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPollCompletion_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPollCompletion_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPollCompletion_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 req = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->req(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPollCompletion_call)
  return target;
}

size_t xclPollCompletion_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPollCompletion_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 req = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->req());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPollCompletion_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPollCompletion_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPollCompletion_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPollCompletion_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPollCompletion_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPollCompletion_call)
    MergeFrom(*source);
  }
}

void xclPollCompletion_call::MergeFrom(const xclPollCompletion_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPollCompletion_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_req()) {
    set_req(from.req());
  }
}

void xclPollCompletion_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPollCompletion_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPollCompletion_call::InternalSwap(xclPollCompletion_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(req_, other->req_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPollCompletion_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPollCompletion_response_request::InitAsDefaultInstance() {
}
class xclPollCompletion_response_request::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPollCompletion_response_request>()._has_bits_);
  static void set_has_dest(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

xclPollCompletion_response_request::xclPollCompletion_response_request()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPollCompletion_response.request)
}
xclPollCompletion_response_request::xclPollCompletion_response_request(const xclPollCompletion_response_request& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_dest()) {
    dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
  }
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:xclPollCompletion_response.request)
}

void xclPollCompletion_response_request::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto.base);
  dest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  size_ = PROTOBUF_ULONGLONG(0);
}

xclPollCompletion_response_request::~xclPollCompletion_response_request() {
  // @@protoc_insertion_point(destructor:xclPollCompletion_response.request)
  SharedDtor();
}

void xclPollCompletion_response_request::SharedDtor() {
  dest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPollCompletion_response_request::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPollCompletion_response_request& xclPollCompletion_response_request::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPollCompletion_response_request_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPollCompletion_response_request::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPollCompletion_response.request)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    dest_.ClearNonDefaultToEmptyNoArena();
  }
  size_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPollCompletion_response_request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bytes dest = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_dest(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPollCompletion_response_request::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPollCompletion_response.request)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes dest = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_dest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_size(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPollCompletion_response.request)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPollCompletion_response.request)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPollCompletion_response_request::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPollCompletion_response.request)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes dest = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->dest(), output);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPollCompletion_response.request)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPollCompletion_response_request::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPollCompletion_response.request)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes dest = 1;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        1, this->dest(), target);
  }

  // optional uint64 size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPollCompletion_response.request)
  return target;
}

size_t xclPollCompletion_response_request::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPollCompletion_response.request)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes dest = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->dest());
    }

    // optional uint64 size = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->size());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPollCompletion_response_request::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPollCompletion_response.request)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPollCompletion_response_request* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPollCompletion_response_request>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPollCompletion_response.request)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPollCompletion_response.request)
    MergeFrom(*source);
  }
}

void xclPollCompletion_response_request::MergeFrom(const xclPollCompletion_response_request& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPollCompletion_response.request)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      dest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dest_);
    }
    if (cached_has_bits & 0x00000002u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPollCompletion_response_request::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPollCompletion_response.request)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPollCompletion_response_request::InternalSwap(xclPollCompletion_response_request* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  dest_.Swap(&other->dest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(size_, other->size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPollCompletion_response_request::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPollCompletion_response::InitAsDefaultInstance() {
}
class xclPollCompletion_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPollCompletion_response>()._has_bits_);
};

xclPollCompletion_response::xclPollCompletion_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPollCompletion_response)
}
xclPollCompletion_response::xclPollCompletion_response(const xclPollCompletion_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      fullrequest_(from.fullrequest_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:xclPollCompletion_response)
}

void xclPollCompletion_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPollCompletion_response_rpc_5fmessages_2eproto.base);
}

xclPollCompletion_response::~xclPollCompletion_response() {
  // @@protoc_insertion_point(destructor:xclPollCompletion_response)
  SharedDtor();
}

void xclPollCompletion_response::SharedDtor() {
}

void xclPollCompletion_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPollCompletion_response& xclPollCompletion_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPollCompletion_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPollCompletion_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPollCompletion_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  fullrequest_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPollCompletion_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .xclPollCompletion_response.request fullrequest = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_fullrequest(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPollCompletion_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPollCompletion_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .xclPollCompletion_response.request fullrequest = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_fullrequest()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPollCompletion_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPollCompletion_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPollCompletion_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPollCompletion_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPollCompletion_response.request fullrequest = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fullrequest_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3,
      this->fullrequest(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPollCompletion_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPollCompletion_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPollCompletion_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPollCompletion_response.request fullrequest = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fullrequest_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->fullrequest(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPollCompletion_response)
  return target;
}

size_t xclPollCompletion_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPollCompletion_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclPollCompletion_response.request fullrequest = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->fullrequest_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->fullrequest(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPollCompletion_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPollCompletion_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPollCompletion_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPollCompletion_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPollCompletion_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPollCompletion_response)
    MergeFrom(*source);
  }
}

void xclPollCompletion_response::MergeFrom(const xclPollCompletion_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPollCompletion_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  fullrequest_.MergeFrom(from.fullrequest_);
}

void xclPollCompletion_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPollCompletion_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPollCompletion_response::InternalSwap(xclPollCompletion_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&fullrequest_)->InternalSwap(CastToBase(&other->fullrequest_));
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPollCompletion_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclDestroyQueue_call::InitAsDefaultInstance() {
}
class xclDestroyQueue_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclDestroyQueue_call>()._has_bits_);
  static void set_has_q_handle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclDestroyQueue_call::xclDestroyQueue_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclDestroyQueue_call)
}
xclDestroyQueue_call::xclDestroyQueue_call(const xclDestroyQueue_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  q_handle_ = from.q_handle_;
  // @@protoc_insertion_point(copy_constructor:xclDestroyQueue_call)
}

void xclDestroyQueue_call::SharedCtor() {
  q_handle_ = PROTOBUF_ULONGLONG(0);
}

xclDestroyQueue_call::~xclDestroyQueue_call() {
  // @@protoc_insertion_point(destructor:xclDestroyQueue_call)
  SharedDtor();
}

void xclDestroyQueue_call::SharedDtor() {
}

void xclDestroyQueue_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclDestroyQueue_call& xclDestroyQueue_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclDestroyQueue_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclDestroyQueue_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclDestroyQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  q_handle_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclDestroyQueue_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 q_handle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_q_handle(&has_bits);
          q_handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclDestroyQueue_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclDestroyQueue_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 q_handle = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_q_handle(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &q_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclDestroyQueue_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclDestroyQueue_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclDestroyQueue_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclDestroyQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->q_handle(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclDestroyQueue_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclDestroyQueue_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclDestroyQueue_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 q_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->q_handle(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclDestroyQueue_call)
  return target;
}

size_t xclDestroyQueue_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclDestroyQueue_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 q_handle = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->q_handle());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclDestroyQueue_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclDestroyQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclDestroyQueue_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclDestroyQueue_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclDestroyQueue_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclDestroyQueue_call)
    MergeFrom(*source);
  }
}

void xclDestroyQueue_call::MergeFrom(const xclDestroyQueue_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclDestroyQueue_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_q_handle()) {
    set_q_handle(from.q_handle());
  }
}

void xclDestroyQueue_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclDestroyQueue_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclDestroyQueue_call::InternalSwap(xclDestroyQueue_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(q_handle_, other->q_handle_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclDestroyQueue_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclDestroyQueue_response::InitAsDefaultInstance() {
}
class xclDestroyQueue_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclDestroyQueue_response>()._has_bits_);
  static void set_has_success(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclDestroyQueue_response::xclDestroyQueue_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclDestroyQueue_response)
}
xclDestroyQueue_response::xclDestroyQueue_response(const xclDestroyQueue_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  success_ = from.success_;
  // @@protoc_insertion_point(copy_constructor:xclDestroyQueue_response)
}

void xclDestroyQueue_response::SharedCtor() {
  success_ = false;
}

xclDestroyQueue_response::~xclDestroyQueue_response() {
  // @@protoc_insertion_point(destructor:xclDestroyQueue_response)
  SharedDtor();
}

void xclDestroyQueue_response::SharedDtor() {
}

void xclDestroyQueue_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclDestroyQueue_response& xclDestroyQueue_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclDestroyQueue_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclDestroyQueue_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclDestroyQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  success_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclDestroyQueue_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool success = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_success(&has_bits);
          success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclDestroyQueue_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclDestroyQueue_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool success = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_success(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &success_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclDestroyQueue_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclDestroyQueue_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclDestroyQueue_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclDestroyQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool success = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->success(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclDestroyQueue_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclDestroyQueue_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclDestroyQueue_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool success = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->success(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclDestroyQueue_response)
  return target;
}

size_t xclDestroyQueue_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclDestroyQueue_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool success = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclDestroyQueue_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclDestroyQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclDestroyQueue_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclDestroyQueue_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclDestroyQueue_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclDestroyQueue_response)
    MergeFrom(*source);
  }
}

void xclDestroyQueue_response::MergeFrom(const xclDestroyQueue_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclDestroyQueue_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_success()) {
    set_success(from.success());
  }
}

void xclDestroyQueue_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclDestroyQueue_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclDestroyQueue_response::InternalSwap(xclDestroyQueue_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(success_, other->success_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclDestroyQueue_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetupInstance_call_argflowpair::InitAsDefaultInstance() {
}
class xclSetupInstance_call_argflowpair::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetupInstance_call_argflowpair>()._has_bits_);
  static void set_has_arg(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_flow(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_tag(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclSetupInstance_call_argflowpair::xclSetupInstance_call_argflowpair()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetupInstance_call.argflowpair)
}
xclSetupInstance_call_argflowpair::xclSetupInstance_call_argflowpair(const xclSetupInstance_call_argflowpair& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_tag()) {
    tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_);
  }
  ::memcpy(&arg_, &from.arg_,
    static_cast<size_t>(reinterpret_cast<char*>(&flow_) -
    reinterpret_cast<char*>(&arg_)) + sizeof(flow_));
  // @@protoc_insertion_point(copy_constructor:xclSetupInstance_call.argflowpair)
}

void xclSetupInstance_call_argflowpair::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto.base);
  tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&arg_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&flow_) -
      reinterpret_cast<char*>(&arg_)) + sizeof(flow_));
}

xclSetupInstance_call_argflowpair::~xclSetupInstance_call_argflowpair() {
  // @@protoc_insertion_point(destructor:xclSetupInstance_call.argflowpair)
  SharedDtor();
}

void xclSetupInstance_call_argflowpair::SharedDtor() {
  tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclSetupInstance_call_argflowpair::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetupInstance_call_argflowpair& xclSetupInstance_call_argflowpair::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetupInstance_call_argflowpair_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetupInstance_call_argflowpair::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetupInstance_call.argflowpair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    tag_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&arg_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flow_) -
        reinterpret_cast<char*>(&arg_)) + sizeof(flow_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetupInstance_call_argflowpair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 arg = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_arg(&has_bits);
          arg_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 flow = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_flow(&has_bits);
          flow_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string tag = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_tag(), ptr, ctx, "xclSetupInstance_call.argflowpair.tag");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetupInstance_call_argflowpair::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetupInstance_call.argflowpair)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 arg = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_arg(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &arg_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 flow = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_flow(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &flow_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string tag = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_tag()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->tag().data(), static_cast<int>(this->tag().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclSetupInstance_call.argflowpair.tag");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetupInstance_call.argflowpair)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetupInstance_call.argflowpair)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetupInstance_call_argflowpair::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetupInstance_call.argflowpair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 arg = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->arg(), output);
  }

  // optional uint64 flow = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->flow(), output);
  }

  // optional string tag = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->tag().data(), static_cast<int>(this->tag().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetupInstance_call.argflowpair.tag");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->tag(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetupInstance_call.argflowpair)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetupInstance_call_argflowpair::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetupInstance_call.argflowpair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 arg = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->arg(), target);
  }

  // optional uint64 flow = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->flow(), target);
  }

  // optional string tag = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->tag().data(), static_cast<int>(this->tag().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclSetupInstance_call.argflowpair.tag");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        4, this->tag(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetupInstance_call.argflowpair)
  return target;
}

size_t xclSetupInstance_call_argflowpair::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetupInstance_call.argflowpair)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string tag = 4;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->tag());
    }

    // optional uint64 arg = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->arg());
    }

    // optional uint64 flow = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->flow());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetupInstance_call_argflowpair::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetupInstance_call.argflowpair)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetupInstance_call_argflowpair* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetupInstance_call_argflowpair>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetupInstance_call.argflowpair)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetupInstance_call.argflowpair)
    MergeFrom(*source);
  }
}

void xclSetupInstance_call_argflowpair::MergeFrom(const xclSetupInstance_call_argflowpair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetupInstance_call.argflowpair)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_);
    }
    if (cached_has_bits & 0x00000002u) {
      arg_ = from.arg_;
    }
    if (cached_has_bits & 0x00000004u) {
      flow_ = from.flow_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclSetupInstance_call_argflowpair::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetupInstance_call.argflowpair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetupInstance_call_argflowpair::InternalSwap(xclSetupInstance_call_argflowpair* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  tag_.Swap(&other->tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(arg_, other->arg_);
  swap(flow_, other->flow_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetupInstance_call_argflowpair::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetupInstance_call::InitAsDefaultInstance() {
}
class xclSetupInstance_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetupInstance_call>()._has_bits_);
  static void set_has_route(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclSetupInstance_call::xclSetupInstance_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetupInstance_call)
}
xclSetupInstance_call::xclSetupInstance_call(const xclSetupInstance_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      setup_(from.setup_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  route_ = from.route_;
  // @@protoc_insertion_point(copy_constructor:xclSetupInstance_call)
}

void xclSetupInstance_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclSetupInstance_call_rpc_5fmessages_2eproto.base);
  route_ = PROTOBUF_ULONGLONG(0);
}

xclSetupInstance_call::~xclSetupInstance_call() {
  // @@protoc_insertion_point(destructor:xclSetupInstance_call)
  SharedDtor();
}

void xclSetupInstance_call::SharedDtor() {
}

void xclSetupInstance_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetupInstance_call& xclSetupInstance_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetupInstance_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetupInstance_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetupInstance_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  setup_.Clear();
  route_ = PROTOBUF_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetupInstance_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 route = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_route(&has_bits);
          route_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .xclSetupInstance_call.argflowpair setup = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_setup(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetupInstance_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetupInstance_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 route = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_route(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &route_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .xclSetupInstance_call.argflowpair setup = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_setup()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetupInstance_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetupInstance_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetupInstance_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetupInstance_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 route = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->route(), output);
  }

  // repeated .xclSetupInstance_call.argflowpair setup = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->setup_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5,
      this->setup(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetupInstance_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetupInstance_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetupInstance_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 route = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->route(), target);
  }

  // repeated .xclSetupInstance_call.argflowpair setup = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->setup_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, this->setup(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetupInstance_call)
  return target;
}

size_t xclSetupInstance_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetupInstance_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclSetupInstance_call.argflowpair setup = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->setup_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->setup(static_cast<int>(i)));
    }
  }

  // optional uint64 route = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->route());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetupInstance_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetupInstance_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetupInstance_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetupInstance_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetupInstance_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetupInstance_call)
    MergeFrom(*source);
  }
}

void xclSetupInstance_call::MergeFrom(const xclSetupInstance_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetupInstance_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  setup_.MergeFrom(from.setup_);
  if (from.has_route()) {
    set_route(from.route());
  }
}

void xclSetupInstance_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetupInstance_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetupInstance_call::InternalSwap(xclSetupInstance_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&setup_)->InternalSwap(CastToBase(&other->setup_));
  swap(route_, other->route_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetupInstance_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclSetupInstance_response::InitAsDefaultInstance() {
}
class xclSetupInstance_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclSetupInstance_response>()._has_bits_);
  static void set_has_success(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclSetupInstance_response::xclSetupInstance_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclSetupInstance_response)
}
xclSetupInstance_response::xclSetupInstance_response(const xclSetupInstance_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  success_ = from.success_;
  // @@protoc_insertion_point(copy_constructor:xclSetupInstance_response)
}

void xclSetupInstance_response::SharedCtor() {
  success_ = false;
}

xclSetupInstance_response::~xclSetupInstance_response() {
  // @@protoc_insertion_point(destructor:xclSetupInstance_response)
  SharedDtor();
}

void xclSetupInstance_response::SharedDtor() {
}

void xclSetupInstance_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclSetupInstance_response& xclSetupInstance_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclSetupInstance_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclSetupInstance_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclSetupInstance_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  success_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclSetupInstance_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool success = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_success(&has_bits);
          success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclSetupInstance_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclSetupInstance_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool success = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_success(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &success_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclSetupInstance_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclSetupInstance_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclSetupInstance_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclSetupInstance_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool success = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->success(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclSetupInstance_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclSetupInstance_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclSetupInstance_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool success = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->success(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclSetupInstance_response)
  return target;
}

size_t xclSetupInstance_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclSetupInstance_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool success = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclSetupInstance_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclSetupInstance_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclSetupInstance_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclSetupInstance_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclSetupInstance_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclSetupInstance_response)
    MergeFrom(*source);
  }
}

void xclSetupInstance_response::MergeFrom(const xclSetupInstance_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclSetupInstance_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_success()) {
    set_success(from.success());
  }
}

void xclSetupInstance_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclSetupInstance_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclSetupInstance_response::InternalSwap(xclSetupInstance_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(success_, other->success_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclSetupInstance_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadCounters_Streaming_call::InitAsDefaultInstance() {
}
class xclPerfMonReadCounters_Streaming_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadCounters_Streaming_call>()._has_bits_);
  static void set_has_slotname(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclPerfMonReadCounters_Streaming_call::xclPerfMonReadCounters_Streaming_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadCounters_Streaming_call)
}
xclPerfMonReadCounters_Streaming_call::xclPerfMonReadCounters_Streaming_call(const xclPerfMonReadCounters_Streaming_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_slotname()) {
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadCounters_Streaming_call)
}

void xclPerfMonReadCounters_Streaming_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto.base);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

xclPerfMonReadCounters_Streaming_call::~xclPerfMonReadCounters_Streaming_call() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadCounters_Streaming_call)
  SharedDtor();
}

void xclPerfMonReadCounters_Streaming_call::SharedDtor() {
  slotname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPerfMonReadCounters_Streaming_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadCounters_Streaming_call& xclPerfMonReadCounters_Streaming_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadCounters_Streaming_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadCounters_Streaming_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadCounters_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    slotname_.ClearNonDefaultToEmptyNoArena();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadCounters_Streaming_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required string slotname = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_slotname(), ptr, ctx, "xclPerfMonReadCounters_Streaming_call.slotname");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadCounters_Streaming_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadCounters_Streaming_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string slotname = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_slotname()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->slotname().data(), static_cast<int>(this->slotname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclPerfMonReadCounters_Streaming_call.slotname");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadCounters_Streaming_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadCounters_Streaming_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadCounters_Streaming_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadCounters_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string slotname = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadCounters_Streaming_call.slotname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->slotname(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadCounters_Streaming_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadCounters_Streaming_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadCounters_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string slotname = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadCounters_Streaming_call.slotname");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->slotname(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadCounters_Streaming_call)
  return target;
}

size_t xclPerfMonReadCounters_Streaming_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadCounters_Streaming_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required string slotname = 1;
  if (has_slotname()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->slotname());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadCounters_Streaming_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadCounters_Streaming_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadCounters_Streaming_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadCounters_Streaming_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadCounters_Streaming_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadCounters_Streaming_call)
    MergeFrom(*source);
  }
}

void xclPerfMonReadCounters_Streaming_call::MergeFrom(const xclPerfMonReadCounters_Streaming_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadCounters_Streaming_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_slotname()) {
    _has_bits_[0] |= 0x00000001u;
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
}

void xclPerfMonReadCounters_Streaming_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadCounters_Streaming_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool xclPerfMonReadCounters_Streaming_call::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void xclPerfMonReadCounters_Streaming_call::InternalSwap(xclPerfMonReadCounters_Streaming_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  slotname_.Swap(&other->slotname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadCounters_Streaming_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadCounters_Streaming_response::InitAsDefaultInstance() {
}
class xclPerfMonReadCounters_Streaming_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadCounters_Streaming_response>()._has_bits_);
  static void set_has_str_num_tranx(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_str_data_bytes(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_str_busy_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_str_stall_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_str_starve_cycles(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

xclPerfMonReadCounters_Streaming_response::xclPerfMonReadCounters_Streaming_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadCounters_Streaming_response)
}
xclPerfMonReadCounters_Streaming_response::xclPerfMonReadCounters_Streaming_response(const xclPerfMonReadCounters_Streaming_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&str_num_tranx_, &from.str_num_tranx_,
    static_cast<size_t>(reinterpret_cast<char*>(&str_starve_cycles_) -
    reinterpret_cast<char*>(&str_num_tranx_)) + sizeof(str_starve_cycles_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadCounters_Streaming_response)
}

void xclPerfMonReadCounters_Streaming_response::SharedCtor() {
  ::memset(&str_num_tranx_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&str_starve_cycles_) -
      reinterpret_cast<char*>(&str_num_tranx_)) + sizeof(str_starve_cycles_));
}

xclPerfMonReadCounters_Streaming_response::~xclPerfMonReadCounters_Streaming_response() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadCounters_Streaming_response)
  SharedDtor();
}

void xclPerfMonReadCounters_Streaming_response::SharedDtor() {
}

void xclPerfMonReadCounters_Streaming_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadCounters_Streaming_response& xclPerfMonReadCounters_Streaming_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadCounters_Streaming_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadCounters_Streaming_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadCounters_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&str_num_tranx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&str_starve_cycles_) -
        reinterpret_cast<char*>(&str_num_tranx_)) + sizeof(str_starve_cycles_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadCounters_Streaming_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 str_num_tranx = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_str_num_tranx(&has_bits);
          str_num_tranx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 str_data_bytes = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_str_data_bytes(&has_bits);
          str_data_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 str_busy_cycles = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_str_busy_cycles(&has_bits);
          str_busy_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 str_stall_cycles = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_str_stall_cycles(&has_bits);
          str_stall_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 str_starve_cycles = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_str_starve_cycles(&has_bits);
          str_starve_cycles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadCounters_Streaming_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadCounters_Streaming_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 str_num_tranx = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_str_num_tranx(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &str_num_tranx_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 str_data_bytes = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) {
          _Internal::set_has_str_data_bytes(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &str_data_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 str_busy_cycles = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) {
          _Internal::set_has_str_busy_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &str_busy_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 str_stall_cycles = 10;
      case 10: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (80 & 0xFF)) {
          _Internal::set_has_str_stall_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &str_stall_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 str_starve_cycles = 11;
      case 11: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (88 & 0xFF)) {
          _Internal::set_has_str_starve_cycles(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &str_starve_cycles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadCounters_Streaming_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadCounters_Streaming_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadCounters_Streaming_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadCounters_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 str_num_tranx = 7;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(7, this->str_num_tranx(), output);
  }

  // optional uint64 str_data_bytes = 8;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(8, this->str_data_bytes(), output);
  }

  // optional uint64 str_busy_cycles = 9;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(9, this->str_busy_cycles(), output);
  }

  // optional uint64 str_stall_cycles = 10;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(10, this->str_stall_cycles(), output);
  }

  // optional uint64 str_starve_cycles = 11;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(11, this->str_starve_cycles(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadCounters_Streaming_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadCounters_Streaming_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadCounters_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 str_num_tranx = 7;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->str_num_tranx(), target);
  }

  // optional uint64 str_data_bytes = 8;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->str_data_bytes(), target);
  }

  // optional uint64 str_busy_cycles = 9;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(9, this->str_busy_cycles(), target);
  }

  // optional uint64 str_stall_cycles = 10;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(10, this->str_stall_cycles(), target);
  }

  // optional uint64 str_starve_cycles = 11;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->str_starve_cycles(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadCounters_Streaming_response)
  return target;
}

size_t xclPerfMonReadCounters_Streaming_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadCounters_Streaming_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional uint64 str_num_tranx = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->str_num_tranx());
    }

    // optional uint64 str_data_bytes = 8;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->str_data_bytes());
    }

    // optional uint64 str_busy_cycles = 9;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->str_busy_cycles());
    }

    // optional uint64 str_stall_cycles = 10;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->str_stall_cycles());
    }

    // optional uint64 str_starve_cycles = 11;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->str_starve_cycles());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadCounters_Streaming_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadCounters_Streaming_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadCounters_Streaming_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadCounters_Streaming_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadCounters_Streaming_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadCounters_Streaming_response)
    MergeFrom(*source);
  }
}

void xclPerfMonReadCounters_Streaming_response::MergeFrom(const xclPerfMonReadCounters_Streaming_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadCounters_Streaming_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      str_num_tranx_ = from.str_num_tranx_;
    }
    if (cached_has_bits & 0x00000002u) {
      str_data_bytes_ = from.str_data_bytes_;
    }
    if (cached_has_bits & 0x00000004u) {
      str_busy_cycles_ = from.str_busy_cycles_;
    }
    if (cached_has_bits & 0x00000008u) {
      str_stall_cycles_ = from.str_stall_cycles_;
    }
    if (cached_has_bits & 0x00000010u) {
      str_starve_cycles_ = from.str_starve_cycles_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadCounters_Streaming_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadCounters_Streaming_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadCounters_Streaming_response::InternalSwap(xclPerfMonReadCounters_Streaming_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(str_num_tranx_, other->str_num_tranx_);
  swap(str_data_bytes_, other->str_data_bytes_);
  swap(str_busy_cycles_, other->str_busy_cycles_);
  swap(str_stall_cycles_, other->str_stall_cycles_);
  swap(str_starve_cycles_, other->str_starve_cycles_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadCounters_Streaming_response::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_Streaming_call::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_Streaming_call::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_Streaming_call>()._has_bits_);
  static void set_has_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_slotname(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

xclPerfMonReadTrace_Streaming_call::xclPerfMonReadTrace_Streaming_call()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_Streaming_call)
}
xclPerfMonReadTrace_Streaming_call::xclPerfMonReadTrace_Streaming_call(const xclPerfMonReadTrace_Streaming_call& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_slotname()) {
    slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
  }
  ack_ = from.ack_;
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_Streaming_call)
}

void xclPerfMonReadTrace_Streaming_call::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto.base);
  slotname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ack_ = false;
}

xclPerfMonReadTrace_Streaming_call::~xclPerfMonReadTrace_Streaming_call() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_Streaming_call)
  SharedDtor();
}

void xclPerfMonReadTrace_Streaming_call::SharedDtor() {
  slotname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void xclPerfMonReadTrace_Streaming_call::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_Streaming_call& xclPerfMonReadTrace_Streaming_call::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_Streaming_call_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_Streaming_call::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    slotname_.ClearNonDefaultToEmptyNoArena();
  }
  ack_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_Streaming_call::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ack = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ack(&has_bits);
          ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string slotname = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_slotname(), ptr, ctx, "xclPerfMonReadTrace_Streaming_call.slotname");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_Streaming_call::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_Streaming_call)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool ack = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ack(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ack_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string slotname = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_slotname()));
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
            this->slotname().data(), static_cast<int>(this->slotname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
            "xclPerfMonReadTrace_Streaming_call.slotname");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_Streaming_call)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_Streaming_call)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_Streaming_call::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->ack(), output);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadTrace_Streaming_call.slotname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->slotname(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_Streaming_call)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_Streaming_call::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_Streaming_call)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ack = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->ack(), target);
  }

  // optional string slotname = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->slotname().data(), static_cast<int>(this->slotname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "xclPerfMonReadTrace_Streaming_call.slotname");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->slotname(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_Streaming_call)
  return target;
}

size_t xclPerfMonReadTrace_Streaming_call::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_Streaming_call)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string slotname = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->slotname());
    }

    // optional bool ack = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_Streaming_call::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_Streaming_call)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_Streaming_call* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_Streaming_call>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_Streaming_call)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_Streaming_call)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_Streaming_call::MergeFrom(const xclPerfMonReadTrace_Streaming_call& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_Streaming_call)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      slotname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.slotname_);
    }
    if (cached_has_bits & 0x00000002u) {
      ack_ = from.ack_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadTrace_Streaming_call::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_Streaming_call)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_Streaming_call::InternalSwap(xclPerfMonReadTrace_Streaming_call* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  slotname_.Swap(&other->slotname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(ack_, other->ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_Streaming_call::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_Streaming_response_events::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_Streaming_response_events::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_Streaming_response_events>()._has_bits_);
  static void set_has_eventflags(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_host_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

xclPerfMonReadTrace_Streaming_response_events::xclPerfMonReadTrace_Streaming_response_events()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_Streaming_response.events)
}
xclPerfMonReadTrace_Streaming_response_events::xclPerfMonReadTrace_Streaming_response_events(const xclPerfMonReadTrace_Streaming_response_events& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&eventflags_, &from.eventflags_,
    static_cast<size_t>(reinterpret_cast<char*>(&host_timestamp_) -
    reinterpret_cast<char*>(&eventflags_)) + sizeof(host_timestamp_));
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_Streaming_response.events)
}

void xclPerfMonReadTrace_Streaming_response_events::SharedCtor() {
  ::memset(&eventflags_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&host_timestamp_) -
      reinterpret_cast<char*>(&eventflags_)) + sizeof(host_timestamp_));
}

xclPerfMonReadTrace_Streaming_response_events::~xclPerfMonReadTrace_Streaming_response_events() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_Streaming_response.events)
  SharedDtor();
}

void xclPerfMonReadTrace_Streaming_response_events::SharedDtor() {
}

void xclPerfMonReadTrace_Streaming_response_events::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_Streaming_response_events& xclPerfMonReadTrace_Streaming_response_events::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_Streaming_response_events_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_Streaming_response_events::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_Streaming_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&eventflags_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&host_timestamp_) -
        reinterpret_cast<char*>(&eventflags_)) + sizeof(host_timestamp_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_Streaming_response_events::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 eventflags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_eventflags(&has_bits);
          eventflags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 timestamp = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_timestamp(&has_bits);
          timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 host_timestamp = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_host_timestamp(&has_bits);
          host_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_Streaming_response_events::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_Streaming_response.events)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 eventflags = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_eventflags(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &eventflags_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 timestamp = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_timestamp(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 host_timestamp = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_host_timestamp(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &host_timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_Streaming_response.events)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_Streaming_response.events)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_Streaming_response_events::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_Streaming_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 eventflags = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->eventflags(), output);
  }

  // optional uint32 timestamp = 4;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->timestamp(), output);
  }

  // optional uint64 host_timestamp = 5;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->host_timestamp(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_Streaming_response.events)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_Streaming_response_events::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_Streaming_response.events)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 eventflags = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->eventflags(), target);
  }

  // optional uint32 timestamp = 4;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->timestamp(), target);
  }

  // optional uint64 host_timestamp = 5;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->host_timestamp(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_Streaming_response.events)
  return target;
}

size_t xclPerfMonReadTrace_Streaming_response_events::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_Streaming_response.events)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional uint32 eventflags = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->eventflags());
    }

    // optional uint32 timestamp = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->timestamp());
    }

    // optional uint64 host_timestamp = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->host_timestamp());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_Streaming_response_events::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_Streaming_response.events)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_Streaming_response_events* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_Streaming_response_events>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_Streaming_response.events)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_Streaming_response.events)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_Streaming_response_events::MergeFrom(const xclPerfMonReadTrace_Streaming_response_events& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_Streaming_response.events)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      eventflags_ = from.eventflags_;
    }
    if (cached_has_bits & 0x00000002u) {
      timestamp_ = from.timestamp_;
    }
    if (cached_has_bits & 0x00000004u) {
      host_timestamp_ = from.host_timestamp_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void xclPerfMonReadTrace_Streaming_response_events::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_Streaming_response.events)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_Streaming_response_events::InternalSwap(xclPerfMonReadTrace_Streaming_response_events* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(eventflags_, other->eventflags_);
  swap(timestamp_, other->timestamp_);
  swap(host_timestamp_, other->host_timestamp_);
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_Streaming_response_events::GetMetadata() const {
  return GetMetadataStatic();
}


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

void xclPerfMonReadTrace_Streaming_response::InitAsDefaultInstance() {
}
class xclPerfMonReadTrace_Streaming_response::_Internal {
 public:
  using HasBits = decltype(std::declval<xclPerfMonReadTrace_Streaming_response>()._has_bits_);
};

xclPerfMonReadTrace_Streaming_response::xclPerfMonReadTrace_Streaming_response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:xclPerfMonReadTrace_Streaming_response)
}
xclPerfMonReadTrace_Streaming_response::xclPerfMonReadTrace_Streaming_response(const xclPerfMonReadTrace_Streaming_response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      output_data_(from.output_data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:xclPerfMonReadTrace_Streaming_response)
}

void xclPerfMonReadTrace_Streaming_response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto.base);
}

xclPerfMonReadTrace_Streaming_response::~xclPerfMonReadTrace_Streaming_response() {
  // @@protoc_insertion_point(destructor:xclPerfMonReadTrace_Streaming_response)
  SharedDtor();
}

void xclPerfMonReadTrace_Streaming_response::SharedDtor() {
}

void xclPerfMonReadTrace_Streaming_response::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const xclPerfMonReadTrace_Streaming_response& xclPerfMonReadTrace_Streaming_response::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_xclPerfMonReadTrace_Streaming_response_rpc_5fmessages_2eproto.base);
  return *internal_default_instance();
}


void xclPerfMonReadTrace_Streaming_response::Clear() {
// @@protoc_insertion_point(message_clear_start:xclPerfMonReadTrace_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  output_data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* xclPerfMonReadTrace_Streaming_response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_output_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool xclPerfMonReadTrace_Streaming_response::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:xclPerfMonReadTrace_Streaming_response)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_output_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:xclPerfMonReadTrace_Streaming_response)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:xclPerfMonReadTrace_Streaming_response)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void xclPerfMonReadTrace_Streaming_response::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:xclPerfMonReadTrace_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->output_data_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      8,
      this->output_data(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:xclPerfMonReadTrace_Streaming_response)
}

::PROTOBUF_NAMESPACE_ID::uint8* xclPerfMonReadTrace_Streaming_response::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:xclPerfMonReadTrace_Streaming_response)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->output_data_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, this->output_data(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:xclPerfMonReadTrace_Streaming_response)
  return target;
}

size_t xclPerfMonReadTrace_Streaming_response::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:xclPerfMonReadTrace_Streaming_response)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .xclPerfMonReadTrace_Streaming_response.events output_data = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->output_data_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->output_data(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void xclPerfMonReadTrace_Streaming_response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:xclPerfMonReadTrace_Streaming_response)
  GOOGLE_DCHECK_NE(&from, this);
  const xclPerfMonReadTrace_Streaming_response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<xclPerfMonReadTrace_Streaming_response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:xclPerfMonReadTrace_Streaming_response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:xclPerfMonReadTrace_Streaming_response)
    MergeFrom(*source);
  }
}

void xclPerfMonReadTrace_Streaming_response::MergeFrom(const xclPerfMonReadTrace_Streaming_response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:xclPerfMonReadTrace_Streaming_response)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  output_data_.MergeFrom(from.output_data_);
}

void xclPerfMonReadTrace_Streaming_response::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:xclPerfMonReadTrace_Streaming_response)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void xclPerfMonReadTrace_Streaming_response::InternalSwap(xclPerfMonReadTrace_Streaming_response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&output_data_)->InternalSwap(CastToBase(&other->output_data_));
}

::PROTOBUF_NAMESPACE_ID::Metadata xclPerfMonReadTrace_Streaming_response::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::call_packet_info* Arena::CreateMaybeMessage< ::call_packet_info >(Arena* arena) {
  return Arena::CreateInternal< ::call_packet_info >(arena);
}
template<> PROTOBUF_NOINLINE ::response_packet_info* Arena::CreateMaybeMessage< ::response_packet_info >(Arena* arena) {
  return Arena::CreateInternal< ::response_packet_info >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetEnvironment_call_namevaluepair* Arena::CreateMaybeMessage< ::xclSetEnvironment_call_namevaluepair >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetEnvironment_call_namevaluepair >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetEnvironment_call* Arena::CreateMaybeMessage< ::xclSetEnvironment_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetEnvironment_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetEnvironment_response* Arena::CreateMaybeMessage< ::xclSetEnvironment_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetEnvironment_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclLoadBitstream_call_ddrbank* Arena::CreateMaybeMessage< ::xclLoadBitstream_call_ddrbank >(Arena* arena) {
  return Arena::CreateInternal< ::xclLoadBitstream_call_ddrbank >(arena);
}
template<> PROTOBUF_NOINLINE ::xclLoadBitstream_call* Arena::CreateMaybeMessage< ::xclLoadBitstream_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclLoadBitstream_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclLoadBitstream_response* Arena::CreateMaybeMessage< ::xclLoadBitstream_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclLoadBitstream_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclAllocDeviceBuffer_call* Arena::CreateMaybeMessage< ::xclAllocDeviceBuffer_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclAllocDeviceBuffer_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclAllocDeviceBuffer_response* Arena::CreateMaybeMessage< ::xclAllocDeviceBuffer_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclAllocDeviceBuffer_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclFreeDeviceBuffer_call* Arena::CreateMaybeMessage< ::xclFreeDeviceBuffer_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclFreeDeviceBuffer_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclFreeDeviceBuffer_response* Arena::CreateMaybeMessage< ::xclFreeDeviceBuffer_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclFreeDeviceBuffer_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclClose_call* Arena::CreateMaybeMessage< ::xclClose_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclClose_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclClose_response* Arena::CreateMaybeMessage< ::xclClose_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclClose_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBufferHost2Device_call* Arena::CreateMaybeMessage< ::xclCopyBufferHost2Device_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBufferHost2Device_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBufferHost2Device_response* Arena::CreateMaybeMessage< ::xclCopyBufferHost2Device_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBufferHost2Device_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBufferDevice2Host_call* Arena::CreateMaybeMessage< ::xclCopyBufferDevice2Host_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBufferDevice2Host_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBufferDevice2Host_response* Arena::CreateMaybeMessage< ::xclCopyBufferDevice2Host_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBufferDevice2Host_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteAddrSpaceDeviceRam_call* Arena::CreateMaybeMessage< ::xclWriteAddrSpaceDeviceRam_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteAddrSpaceDeviceRam_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteAddrSpaceDeviceRam_response* Arena::CreateMaybeMessage< ::xclWriteAddrSpaceDeviceRam_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteAddrSpaceDeviceRam_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteAddrKernelCtrl_call_kernelInfo* Arena::CreateMaybeMessage< ::xclWriteAddrKernelCtrl_call_kernelInfo >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteAddrKernelCtrl_call_kernelInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteAddrKernelCtrl_call* Arena::CreateMaybeMessage< ::xclWriteAddrKernelCtrl_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteAddrKernelCtrl_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteAddrKernelCtrl_response* Arena::CreateMaybeMessage< ::xclWriteAddrKernelCtrl_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteAddrKernelCtrl_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadAddrSpaceDeviceRam_call* Arena::CreateMaybeMessage< ::xclReadAddrSpaceDeviceRam_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadAddrSpaceDeviceRam_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadAddrSpaceDeviceRam_response* Arena::CreateMaybeMessage< ::xclReadAddrSpaceDeviceRam_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadAddrSpaceDeviceRam_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadAddrKernelCtrl_call* Arena::CreateMaybeMessage< ::xclReadAddrKernelCtrl_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadAddrKernelCtrl_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadAddrKernelCtrl_response* Arena::CreateMaybeMessage< ::xclReadAddrKernelCtrl_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadAddrKernelCtrl_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadCounters_call* Arena::CreateMaybeMessage< ::xclPerfMonReadCounters_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadCounters_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadCounters_response* Arena::CreateMaybeMessage< ::xclPerfMonReadCounters_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadCounters_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonGetTraceCount_call* Arena::CreateMaybeMessage< ::xclPerfMonGetTraceCount_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonGetTraceCount_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonGetTraceCount_response* Arena::CreateMaybeMessage< ::xclPerfMonGetTraceCount_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonGetTraceCount_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_call* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_response_events* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_response_events >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_response_events >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_response* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_response >(arena);
}
template<> PROTOBUF_NOINLINE ::ddr_mem_msg* Arena::CreateMaybeMessage< ::ddr_mem_msg >(Arena* arena) {
  return Arena::CreateInternal< ::ddr_mem_msg >(arena);
}
template<> PROTOBUF_NOINLINE ::xclGetDeviceTimestamp_call* Arena::CreateMaybeMessage< ::xclGetDeviceTimestamp_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclGetDeviceTimestamp_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclGetDeviceTimestamp_response* Arena::CreateMaybeMessage< ::xclGetDeviceTimestamp_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclGetDeviceTimestamp_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadBusStatus_call* Arena::CreateMaybeMessage< ::xclReadBusStatus_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadBusStatus_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadBusStatus_response* Arena::CreateMaybeMessage< ::xclReadBusStatus_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadBusStatus_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclGetDebugMessages_call* Arena::CreateMaybeMessage< ::xclGetDebugMessages_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclGetDebugMessages_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclGetDebugMessages_response* Arena::CreateMaybeMessage< ::xclGetDebugMessages_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclGetDebugMessages_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclImportBO_call* Arena::CreateMaybeMessage< ::xclImportBO_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclImportBO_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclImportBO_response* Arena::CreateMaybeMessage< ::xclImportBO_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclImportBO_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBO_call* Arena::CreateMaybeMessage< ::xclCopyBO_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBO_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCopyBO_response* Arena::CreateMaybeMessage< ::xclCopyBO_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclCopyBO_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCreateQueue_call* Arena::CreateMaybeMessage< ::xclCreateQueue_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclCreateQueue_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclCreateQueue_response* Arena::CreateMaybeMessage< ::xclCreateQueue_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclCreateQueue_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteQueue_call* Arena::CreateMaybeMessage< ::xclWriteQueue_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteQueue_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclWriteQueue_response* Arena::CreateMaybeMessage< ::xclWriteQueue_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclWriteQueue_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadQueue_call* Arena::CreateMaybeMessage< ::xclReadQueue_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadQueue_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclReadQueue_response* Arena::CreateMaybeMessage< ::xclReadQueue_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclReadQueue_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPollCompletion_call* Arena::CreateMaybeMessage< ::xclPollCompletion_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPollCompletion_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPollCompletion_response_request* Arena::CreateMaybeMessage< ::xclPollCompletion_response_request >(Arena* arena) {
  return Arena::CreateInternal< ::xclPollCompletion_response_request >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPollCompletion_response* Arena::CreateMaybeMessage< ::xclPollCompletion_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPollCompletion_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclDestroyQueue_call* Arena::CreateMaybeMessage< ::xclDestroyQueue_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclDestroyQueue_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclDestroyQueue_response* Arena::CreateMaybeMessage< ::xclDestroyQueue_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclDestroyQueue_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetupInstance_call_argflowpair* Arena::CreateMaybeMessage< ::xclSetupInstance_call_argflowpair >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetupInstance_call_argflowpair >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetupInstance_call* Arena::CreateMaybeMessage< ::xclSetupInstance_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetupInstance_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclSetupInstance_response* Arena::CreateMaybeMessage< ::xclSetupInstance_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclSetupInstance_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadCounters_Streaming_call* Arena::CreateMaybeMessage< ::xclPerfMonReadCounters_Streaming_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadCounters_Streaming_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadCounters_Streaming_response* Arena::CreateMaybeMessage< ::xclPerfMonReadCounters_Streaming_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadCounters_Streaming_response >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_Streaming_call* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_Streaming_call >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_Streaming_call >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_Streaming_response_events* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_Streaming_response_events >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_Streaming_response_events >(arena);
}
template<> PROTOBUF_NOINLINE ::xclPerfMonReadTrace_Streaming_response* Arena::CreateMaybeMessage< ::xclPerfMonReadTrace_Streaming_response >(Arena* arena) {
  return Arena::CreateInternal< ::xclPerfMonReadTrace_Streaming_response >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
