/*
 * Copyright (C) 2019-2021 Deutsche Telekom AG
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: backend/failure_detector/db_messages.proto */

/* Do not generate deprecated warnings for self */
#ifndef PROTOBUF_C__NO_DEPRECATED
#define PROTOBUF_C__NO_DEPRECATED
#endif

#include "db_messages.pb-c.h"
void   node_state_message__init
                     (NodeStateMessage         *message)
{
  static const NodeStateMessage init_value = NODE_STATE_MESSAGE__INIT;
  *message = init_value;
}
size_t node_state_message__get_packed_size
                     (const NodeStateMessage *message)
{
  assert(message->base.descriptor == &node_state_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t node_state_message__pack
                     (const NodeStateMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &node_state_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t node_state_message__pack_to_buffer
                     (const NodeStateMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &node_state_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
NodeStateMessage *
       node_state_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (NodeStateMessage *)
     protobuf_c_message_unpack (&node_state_message__descriptor,
                                allocator, len, data);
}
void   node_state_message__free_unpacked
                     (NodeStateMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &node_state_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   vector_clock_message__init
                     (VectorClockMessage         *message)
{
  static const VectorClockMessage init_value = VECTOR_CLOCK_MESSAGE__INIT;
  *message = init_value;
}
size_t vector_clock_message__get_packed_size
                     (const VectorClockMessage *message)
{
  assert(message->base.descriptor == &vector_clock_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t vector_clock_message__pack
                     (const VectorClockMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &vector_clock_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t vector_clock_message__pack_to_buffer
                     (const VectorClockMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &vector_clock_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
VectorClockMessage *
       vector_clock_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (VectorClockMessage *)
     protobuf_c_message_unpack (&vector_clock_message__descriptor,
                                allocator, len, data);
}
void   vector_clock_message__free_unpacked
                     (VectorClockMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &vector_clock_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip_message__init
                     (GossipMessage         *message)
{
  static const GossipMessage init_value = GOSSIP_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip_message__get_packed_size
                     (const GossipMessage *message)
{
  assert(message->base.descriptor == &gossip_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip_message__pack
                     (const GossipMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip_message__pack_to_buffer
                     (const GossipMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
GossipMessage *
       gossip_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (GossipMessage *)
     protobuf_c_message_unpack (&gossip_message__descriptor,
                                allocator, len, data);
}
void   gossip_message__free_unpacked
                     (GossipMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &gossip_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip_listen_message__init
                     (GossipListenMessage         *message)
{
  static const GossipListenMessage init_value = GOSSIP_LISTEN_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip_listen_message__get_packed_size
                     (const GossipListenMessage *message)
{
  assert(message->base.descriptor == &gossip_listen_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip_listen_message__pack
                     (const GossipListenMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip_listen_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip_listen_message__pack_to_buffer
                     (const GossipListenMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip_listen_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
GossipListenMessage *
       gossip_listen_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (GossipListenMessage *)
     protobuf_c_message_unpack (&gossip_listen_message__descriptor,
                                allocator, len, data);
}
void   gossip_listen_message__free_unpacked
                     (GossipListenMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &gossip_listen_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   membership_view_message__init
                     (MembershipViewMessage         *message)
{
  static const MembershipViewMessage init_value = MEMBERSHIP_VIEW_MESSAGE__INIT;
  *message = init_value;
}
size_t membership_view_message__get_packed_size
                     (const MembershipViewMessage *message)
{
  assert(message->base.descriptor == &membership_view_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t membership_view_message__pack
                     (const MembershipViewMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &membership_view_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t membership_view_message__pack_to_buffer
                     (const MembershipViewMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &membership_view_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MembershipViewMessage *
       membership_view_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MembershipViewMessage *)
     protobuf_c_message_unpack (&membership_view_message__descriptor,
                                allocator, len, data);
}
void   membership_view_message__free_unpacked
                     (MembershipViewMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &membership_view_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   membership_agreement_message__init
                     (MembershipAgreementMessage         *message)
{
  static const MembershipAgreementMessage init_value = MEMBERSHIP_AGREEMENT_MESSAGE__INIT;
  *message = init_value;
}
size_t membership_agreement_message__get_packed_size
                     (const MembershipAgreementMessage *message)
{
  assert(message->base.descriptor == &membership_agreement_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t membership_agreement_message__pack
                     (const MembershipAgreementMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &membership_agreement_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t membership_agreement_message__pack_to_buffer
                     (const MembershipAgreementMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &membership_agreement_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MembershipAgreementMessage *
       membership_agreement_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MembershipAgreementMessage *)
     protobuf_c_message_unpack (&membership_agreement_message__descriptor,
                                allocator, len, data);
}
void   membership_agreement_message__free_unpacked
                     (MembershipAgreementMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &membership_agreement_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   cell_address_message__init
                     (CellAddressMessage         *message)
{
  static const CellAddressMessage init_value = CELL_ADDRESS_MESSAGE__INIT;
  *message = init_value;
}
size_t cell_address_message__get_packed_size
                     (const CellAddressMessage *message)
{
  assert(message->base.descriptor == &cell_address_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t cell_address_message__pack
                     (const CellAddressMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &cell_address_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t cell_address_message__pack_to_buffer
                     (const CellAddressMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &cell_address_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
CellAddressMessage *
       cell_address_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (CellAddressMessage *)
     protobuf_c_message_unpack (&cell_address_message__descriptor,
                                allocator, len, data);
}
void   cell_address_message__free_unpacked
                     (CellAddressMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &cell_address_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   cell_message__init
                     (CellMessage         *message)
{
  static const CellMessage init_value = CELL_MESSAGE__INIT;
  *message = init_value;
}
size_t cell_message__get_packed_size
                     (const CellMessage *message)
{
  assert(message->base.descriptor == &cell_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t cell_message__pack
                     (const CellMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &cell_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t cell_message__pack_to_buffer
                     (const CellMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &cell_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
CellMessage *
       cell_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (CellMessage *)
     protobuf_c_message_unpack (&cell_message__descriptor,
                                allocator, len, data);
}
void   cell_message__free_unpacked
                     (CellMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &cell_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   versioned_cell_message__init
                     (VersionedCellMessage         *message)
{
  static const VersionedCellMessage init_value = VERSIONED_CELL_MESSAGE__INIT;
  *message = init_value;
}
size_t versioned_cell_message__get_packed_size
                     (const VersionedCellMessage *message)
{
  assert(message->base.descriptor == &versioned_cell_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t versioned_cell_message__pack
                     (const VersionedCellMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &versioned_cell_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t versioned_cell_message__pack_to_buffer
                     (const VersionedCellMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &versioned_cell_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
VersionedCellMessage *
       versioned_cell_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (VersionedCellMessage *)
     protobuf_c_message_unpack (&versioned_cell_message__descriptor,
                                allocator, len, data);
}
void   versioned_cell_message__free_unpacked
                     (VersionedCellMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &versioned_cell_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   server_message__init
                     (ServerMessage         *message)
{
  static const ServerMessage init_value = SERVER_MESSAGE__INIT;
  *message = init_value;
}
size_t server_message__get_packed_size
                     (const ServerMessage *message)
{
  assert(message->base.descriptor == &server_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t server_message__pack
                     (const ServerMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &server_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t server_message__pack_to_buffer
                     (const ServerMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &server_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ServerMessage *
       server_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ServerMessage *)
     protobuf_c_message_unpack (&server_message__descriptor,
                                allocator, len, data);
}
void   server_message__free_unpacked
                     (ServerMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &server_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   client_message__init
                     (ClientMessage         *message)
{
  static const ClientMessage init_value = CLIENT_MESSAGE__INIT;
  *message = init_value;
}
size_t client_message__get_packed_size
                     (const ClientMessage *message)
{
  assert(message->base.descriptor == &client_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t client_message__pack
                     (const ClientMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &client_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t client_message__pack_to_buffer
                     (const ClientMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &client_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ClientMessage *
       client_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ClientMessage *)
     protobuf_c_message_unpack (&client_message__descriptor,
                                allocator, len, data);
}
void   client_message__free_unpacked
                     (ClientMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &client_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   write_query_message__init
                     (WriteQueryMessage         *message)
{
  static const WriteQueryMessage init_value = WRITE_QUERY_MESSAGE__INIT;
  *message = init_value;
}
size_t write_query_message__get_packed_size
                     (const WriteQueryMessage *message)
{
  assert(message->base.descriptor == &write_query_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t write_query_message__pack
                     (const WriteQueryMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &write_query_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t write_query_message__pack_to_buffer
                     (const WriteQueryMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &write_query_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
WriteQueryMessage *
       write_query_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (WriteQueryMessage *)
     protobuf_c_message_unpack (&write_query_message__descriptor,
                                allocator, len, data);
}
void   write_query_message__free_unpacked
                     (WriteQueryMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &write_query_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   read_query_message__init
                     (ReadQueryMessage         *message)
{
  static const ReadQueryMessage init_value = READ_QUERY_MESSAGE__INIT;
  *message = init_value;
}
size_t read_query_message__get_packed_size
                     (const ReadQueryMessage *message)
{
  assert(message->base.descriptor == &read_query_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t read_query_message__pack
                     (const ReadQueryMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &read_query_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t read_query_message__pack_to_buffer
                     (const ReadQueryMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &read_query_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ReadQueryMessage *
       read_query_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ReadQueryMessage *)
     protobuf_c_message_unpack (&read_query_message__descriptor,
                                allocator, len, data);
}
void   read_query_message__free_unpacked
                     (ReadQueryMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &read_query_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   ack_message__init
                     (AckMessage         *message)
{
  static const AckMessage init_value = ACK_MESSAGE__INIT;
  *message = init_value;
}
size_t ack_message__get_packed_size
                     (const AckMessage *message)
{
  assert(message->base.descriptor == &ack_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t ack_message__pack
                     (const AckMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &ack_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t ack_message__pack_to_buffer
                     (const AckMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &ack_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
AckMessage *
       ack_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (AckMessage *)
     protobuf_c_message_unpack (&ack_message__descriptor,
                                allocator, len, data);
}
void   ack_message__free_unpacked
                     (AckMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &ack_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   range_read_query_message__init
                     (RangeReadQueryMessage         *message)
{
  static const RangeReadQueryMessage init_value = RANGE_READ_QUERY_MESSAGE__INIT;
  *message = init_value;
}
size_t range_read_query_message__get_packed_size
                     (const RangeReadQueryMessage *message)
{
  assert(message->base.descriptor == &range_read_query_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t range_read_query_message__pack
                     (const RangeReadQueryMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &range_read_query_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t range_read_query_message__pack_to_buffer
                     (const RangeReadQueryMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &range_read_query_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
RangeReadQueryMessage *
       range_read_query_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (RangeReadQueryMessage *)
     protobuf_c_message_unpack (&range_read_query_message__descriptor,
                                allocator, len, data);
}
void   range_read_query_message__free_unpacked
                     (RangeReadQueryMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &range_read_query_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   range_read_response_message__init
                     (RangeReadResponseMessage         *message)
{
  static const RangeReadResponseMessage init_value = RANGE_READ_RESPONSE_MESSAGE__INIT;
  *message = init_value;
}
size_t range_read_response_message__get_packed_size
                     (const RangeReadResponseMessage *message)
{
  assert(message->base.descriptor == &range_read_response_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t range_read_response_message__pack
                     (const RangeReadResponseMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &range_read_response_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t range_read_response_message__pack_to_buffer
                     (const RangeReadResponseMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &range_read_response_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
RangeReadResponseMessage *
       range_read_response_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (RangeReadResponseMessage *)
     protobuf_c_message_unpack (&range_read_response_message__descriptor,
                                allocator, len, data);
}
void   range_read_response_message__free_unpacked
                     (RangeReadResponseMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &range_read_response_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   txn_message__init
                     (TxnMessage         *message)
{
  static const TxnMessage init_value = TXN_MESSAGE__INIT;
  *message = init_value;
}
size_t txn_message__get_packed_size
                     (const TxnMessage *message)
{
  assert(message->base.descriptor == &txn_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t txn_message__pack
                     (const TxnMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &txn_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t txn_message__pack_to_buffer
                     (const TxnMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &txn_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
TxnMessage *
       txn_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (TxnMessage *)
     protobuf_c_message_unpack (&txn_message__descriptor,
                                allocator, len, data);
}
void   txn_message__free_unpacked
                     (TxnMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &txn_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   queue_query_message__init
                     (QueueQueryMessage         *message)
{
  static const QueueQueryMessage init_value = QUEUE_QUERY_MESSAGE__INIT;
  *message = init_value;
}
size_t queue_query_message__get_packed_size
                     (const QueueQueryMessage *message)
{
  assert(message->base.descriptor == &queue_query_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t queue_query_message__pack
                     (const QueueQueryMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &queue_query_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t queue_query_message__pack_to_buffer
                     (const QueueQueryMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &queue_query_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
QueueQueryMessage *
       queue_query_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (QueueQueryMessage *)
     protobuf_c_message_unpack (&queue_query_message__descriptor,
                                allocator, len, data);
}
void   queue_query_message__free_unpacked
                     (QueueQueryMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &queue_query_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   consumer_id__init
                     (ConsumerID         *message)
{
  static const ConsumerID init_value = CONSUMER_ID__INIT;
  *message = init_value;
}
size_t consumer_id__get_packed_size
                     (const ConsumerID *message)
{
  assert(message->base.descriptor == &consumer_id__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t consumer_id__pack
                     (const ConsumerID *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &consumer_id__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t consumer_id__pack_to_buffer
                     (const ConsumerID *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &consumer_id__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ConsumerID *
       consumer_id__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ConsumerID *)
     protobuf_c_message_unpack (&consumer_id__descriptor,
                                allocator, len, data);
}
void   consumer_id__free_unpacked
                     (ConsumerID *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &consumer_id__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   create_queue_message__init
                     (CreateQueueMessage         *message)
{
  static const CreateQueueMessage init_value = CREATE_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t create_queue_message__get_packed_size
                     (const CreateQueueMessage *message)
{
  assert(message->base.descriptor == &create_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t create_queue_message__pack
                     (const CreateQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &create_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t create_queue_message__pack_to_buffer
                     (const CreateQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &create_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
CreateQueueMessage *
       create_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (CreateQueueMessage *)
     protobuf_c_message_unpack (&create_queue_message__descriptor,
                                allocator, len, data);
}
void   create_queue_message__free_unpacked
                     (CreateQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &create_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   delete_queue_message__init
                     (DeleteQueueMessage         *message)
{
  static const DeleteQueueMessage init_value = DELETE_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t delete_queue_message__get_packed_size
                     (const DeleteQueueMessage *message)
{
  assert(message->base.descriptor == &delete_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t delete_queue_message__pack
                     (const DeleteQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &delete_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t delete_queue_message__pack_to_buffer
                     (const DeleteQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &delete_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
DeleteQueueMessage *
       delete_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (DeleteQueueMessage *)
     protobuf_c_message_unpack (&delete_queue_message__descriptor,
                                allocator, len, data);
}
void   delete_queue_message__free_unpacked
                     (DeleteQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &delete_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   subscribe_queue_message__init
                     (SubscribeQueueMessage         *message)
{
  static const SubscribeQueueMessage init_value = SUBSCRIBE_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t subscribe_queue_message__get_packed_size
                     (const SubscribeQueueMessage *message)
{
  assert(message->base.descriptor == &subscribe_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t subscribe_queue_message__pack
                     (const SubscribeQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &subscribe_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t subscribe_queue_message__pack_to_buffer
                     (const SubscribeQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &subscribe_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SubscribeQueueMessage *
       subscribe_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SubscribeQueueMessage *)
     protobuf_c_message_unpack (&subscribe_queue_message__descriptor,
                                allocator, len, data);
}
void   subscribe_queue_message__free_unpacked
                     (SubscribeQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &subscribe_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   unsubscribe_queue_message__init
                     (UnsubscribeQueueMessage         *message)
{
  static const UnsubscribeQueueMessage init_value = UNSUBSCRIBE_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t unsubscribe_queue_message__get_packed_size
                     (const UnsubscribeQueueMessage *message)
{
  assert(message->base.descriptor == &unsubscribe_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t unsubscribe_queue_message__pack
                     (const UnsubscribeQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &unsubscribe_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t unsubscribe_queue_message__pack_to_buffer
                     (const UnsubscribeQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &unsubscribe_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
UnsubscribeQueueMessage *
       unsubscribe_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (UnsubscribeQueueMessage *)
     protobuf_c_message_unpack (&unsubscribe_queue_message__descriptor,
                                allocator, len, data);
}
void   unsubscribe_queue_message__free_unpacked
                     (UnsubscribeQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &unsubscribe_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   enqueue_message__init
                     (EnqueueMessage         *message)
{
  static const EnqueueMessage init_value = ENQUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t enqueue_message__get_packed_size
                     (const EnqueueMessage *message)
{
  assert(message->base.descriptor == &enqueue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t enqueue_message__pack
                     (const EnqueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &enqueue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t enqueue_message__pack_to_buffer
                     (const EnqueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &enqueue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
EnqueueMessage *
       enqueue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (EnqueueMessage *)
     protobuf_c_message_unpack (&enqueue_message__descriptor,
                                allocator, len, data);
}
void   enqueue_message__free_unpacked
                     (EnqueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &enqueue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   enqueue_response_message__init
                     (EnqueueResponseMessage         *message)
{
  static const EnqueueResponseMessage init_value = ENQUEUE_RESPONSE_MESSAGE__INIT;
  *message = init_value;
}
size_t enqueue_response_message__get_packed_size
                     (const EnqueueResponseMessage *message)
{
  assert(message->base.descriptor == &enqueue_response_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t enqueue_response_message__pack
                     (const EnqueueResponseMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &enqueue_response_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t enqueue_response_message__pack_to_buffer
                     (const EnqueueResponseMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &enqueue_response_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
EnqueueResponseMessage *
       enqueue_response_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (EnqueueResponseMessage *)
     protobuf_c_message_unpack (&enqueue_response_message__descriptor,
                                allocator, len, data);
}
void   enqueue_response_message__free_unpacked
                     (EnqueueResponseMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &enqueue_response_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   read_queue_message__init
                     (ReadQueueMessage         *message)
{
  static const ReadQueueMessage init_value = READ_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t read_queue_message__get_packed_size
                     (const ReadQueueMessage *message)
{
  assert(message->base.descriptor == &read_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t read_queue_message__pack
                     (const ReadQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &read_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t read_queue_message__pack_to_buffer
                     (const ReadQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &read_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ReadQueueMessage *
       read_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ReadQueueMessage *)
     protobuf_c_message_unpack (&read_queue_message__descriptor,
                                allocator, len, data);
}
void   read_queue_message__free_unpacked
                     (ReadQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &read_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   read_queue_response_message__init
                     (ReadQueueResponseMessage         *message)
{
  static const ReadQueueResponseMessage init_value = READ_QUEUE_RESPONSE_MESSAGE__INIT;
  *message = init_value;
}
size_t read_queue_response_message__get_packed_size
                     (const ReadQueueResponseMessage *message)
{
  assert(message->base.descriptor == &read_queue_response_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t read_queue_response_message__pack
                     (const ReadQueueResponseMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &read_queue_response_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t read_queue_response_message__pack_to_buffer
                     (const ReadQueueResponseMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &read_queue_response_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ReadQueueResponseMessage *
       read_queue_response_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ReadQueueResponseMessage *)
     protobuf_c_message_unpack (&read_queue_response_message__descriptor,
                                allocator, len, data);
}
void   read_queue_response_message__free_unpacked
                     (ReadQueueResponseMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &read_queue_response_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   consume_queue_message__init
                     (ConsumeQueueMessage         *message)
{
  static const ConsumeQueueMessage init_value = CONSUME_QUEUE_MESSAGE__INIT;
  *message = init_value;
}
size_t consume_queue_message__get_packed_size
                     (const ConsumeQueueMessage *message)
{
  assert(message->base.descriptor == &consume_queue_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t consume_queue_message__pack
                     (const ConsumeQueueMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &consume_queue_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t consume_queue_message__pack_to_buffer
                     (const ConsumeQueueMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &consume_queue_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ConsumeQueueMessage *
       consume_queue_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ConsumeQueueMessage *)
     protobuf_c_message_unpack (&consume_queue_message__descriptor,
                                allocator, len, data);
}
void   consume_queue_message__free_unpacked
                     (ConsumeQueueMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &consume_queue_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   consume_queue_response_message__init
                     (ConsumeQueueResponseMessage         *message)
{
  static const ConsumeQueueResponseMessage init_value = CONSUME_QUEUE_RESPONSE_MESSAGE__INIT;
  *message = init_value;
}
size_t consume_queue_response_message__get_packed_size
                     (const ConsumeQueueResponseMessage *message)
{
  assert(message->base.descriptor == &consume_queue_response_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t consume_queue_response_message__pack
                     (const ConsumeQueueResponseMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &consume_queue_response_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t consume_queue_response_message__pack_to_buffer
                     (const ConsumeQueueResponseMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &consume_queue_response_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
ConsumeQueueResponseMessage *
       consume_queue_response_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (ConsumeQueueResponseMessage *)
     protobuf_c_message_unpack (&consume_queue_response_message__descriptor,
                                allocator, len, data);
}
void   consume_queue_response_message__free_unpacked
                     (ConsumeQueueResponseMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &consume_queue_response_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
static const ProtobufCFieldDescriptor node_state_message__field_descriptors[6] =
{
  {
    "status",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "node_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, node_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hostname",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, hostname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "port",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, port),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rack_id",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, rack_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dc_id",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(NodeStateMessage, dc_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned node_state_message__field_indices_by_name[] = {
  5,   /* field[5] = dc_id */
  2,   /* field[2] = hostname */
  1,   /* field[1] = node_id */
  3,   /* field[3] = port */
  4,   /* field[4] = rack_id */
  0,   /* field[0] = status */
};
static const ProtobufCIntRange node_state_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor node_state_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "NodeStateMessage",
  "NodeStateMessage",
  "NodeStateMessage",
  "",
  sizeof(NodeStateMessage),
  6,
  node_state_message__field_descriptors,
  node_state_message__field_indices_by_name,
  1,  node_state_message__number_ranges,
  (ProtobufCMessageInit) node_state_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor vector_clock_message__field_descriptors[2] =
{
  {
    "ids",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(VectorClockMessage, n_ids),
    offsetof(VectorClockMessage, ids),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "counters",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(VectorClockMessage, n_counters),
    offsetof(VectorClockMessage, counters),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned vector_clock_message__field_indices_by_name[] = {
  1,   /* field[1] = counters */
  0,   /* field[0] = ids */
};
static const ProtobufCIntRange vector_clock_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor vector_clock_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "VectorClockMessage",
  "VectorClockMessage",
  "VectorClockMessage",
  "",
  sizeof(VectorClockMessage),
  2,
  vector_clock_message__field_descriptors,
  vector_clock_message__field_indices_by_name,
  1,  vector_clock_message__number_ranges,
  (ProtobufCMessageInit) vector_clock_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip_message__field_descriptors[2] =
{
  {
    "node_state",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(GossipMessage, node_state),
    &node_state_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vc",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(GossipMessage, vc),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip_message__field_indices_by_name[] = {
  0,   /* field[0] = node_state */
  1,   /* field[1] = vc */
};
static const ProtobufCIntRange gossip_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "GossipMessage",
  "GossipMessage",
  "GossipMessage",
  "",
  sizeof(GossipMessage),
  2,
  gossip_message__field_descriptors,
  gossip_message__field_indices_by_name,
  1,  gossip_message__number_ranges,
  (ProtobufCMessageInit) gossip_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip_listen_message__field_descriptors[2] =
{
  {
    "node_state",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(GossipListenMessage, node_state),
    &node_state_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(GossipListenMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip_listen_message__field_indices_by_name[] = {
  0,   /* field[0] = node_state */
  1,   /* field[1] = nonce */
};
static const ProtobufCIntRange gossip_listen_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip_listen_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "GossipListenMessage",
  "GossipListenMessage",
  "GossipListenMessage",
  "",
  sizeof(GossipListenMessage),
  2,
  gossip_listen_message__field_descriptors,
  gossip_listen_message__field_indices_by_name,
  1,  gossip_listen_message__number_ranges,
  (ProtobufCMessageInit) gossip_listen_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor membership_view_message__field_descriptors[3] =
{
  {
    "membership",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MembershipViewMessage, n_membership),
    offsetof(MembershipViewMessage, membership),
    &node_state_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "client_membership",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MembershipViewMessage, n_client_membership),
    offsetof(MembershipViewMessage, client_membership),
    &node_state_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "view_id",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MembershipViewMessage, view_id),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned membership_view_message__field_indices_by_name[] = {
  1,   /* field[1] = client_membership */
  0,   /* field[0] = membership */
  2,   /* field[2] = view_id */
};
static const ProtobufCIntRange membership_view_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor membership_view_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MembershipViewMessage",
  "MembershipViewMessage",
  "MembershipViewMessage",
  "",
  sizeof(MembershipViewMessage),
  3,
  membership_view_message__field_descriptors,
  membership_view_message__field_indices_by_name,
  1,  membership_view_message__number_ranges,
  (ProtobufCMessageInit) membership_view_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor membership_agreement_message__field_descriptors[5] =
{
  {
    "msg_type",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(MembershipAgreementMessage, msg_type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ack_status",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(MembershipAgreementMessage, ack_status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "view",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MembershipAgreementMessage, view),
    &membership_view_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(MembershipAgreementMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vc",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MembershipAgreementMessage, vc),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned membership_agreement_message__field_indices_by_name[] = {
  1,   /* field[1] = ack_status */
  0,   /* field[0] = msg_type */
  3,   /* field[3] = nonce */
  4,   /* field[4] = vc */
  2,   /* field[2] = view */
};
static const ProtobufCIntRange membership_agreement_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor membership_agreement_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MembershipAgreementMessage",
  "MembershipAgreementMessage",
  "MembershipAgreementMessage",
  "",
  sizeof(MembershipAgreementMessage),
  5,
  membership_agreement_message__field_descriptors,
  membership_agreement_message__field_indices_by_name,
  1,  membership_agreement_message__number_ranges,
  (ProtobufCMessageInit) membership_agreement_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor cell_address_message__field_descriptors[2] =
{
  {
    "table_key",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(CellAddressMessage, table_key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(CellAddressMessage, n_keys),
    offsetof(CellAddressMessage, keys),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned cell_address_message__field_indices_by_name[] = {
  1,   /* field[1] = keys */
  0,   /* field[0] = table_key */
};
static const ProtobufCIntRange cell_address_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor cell_address_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "CellAddressMessage",
  "CellAddressMessage",
  "CellAddressMessage",
  "",
  sizeof(CellAddressMessage),
  2,
  cell_address_message__field_descriptors,
  cell_address_message__field_indices_by_name,
  1,  cell_address_message__number_ranges,
  (ProtobufCMessageInit) cell_address_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor cell_message__field_descriptors[3] =
{
  {
    "table_key",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(CellMessage, table_key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(CellMessage, n_keys),
    offsetof(CellMessage, keys),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "columns",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(CellMessage, n_columns),
    offsetof(CellMessage, columns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned cell_message__field_indices_by_name[] = {
  2,   /* field[2] = columns */
  1,   /* field[1] = keys */
  0,   /* field[0] = table_key */
};
static const ProtobufCIntRange cell_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor cell_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "CellMessage",
  "CellMessage",
  "CellMessage",
  "",
  sizeof(CellMessage),
  3,
  cell_message__field_descriptors,
  cell_message__field_indices_by_name,
  1,  cell_message__number_ranges,
  (ProtobufCMessageInit) cell_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor versioned_cell_message__field_descriptors[5] =
{
  {
    "table_key",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(VersionedCellMessage, table_key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(VersionedCellMessage, n_keys),
    offsetof(VersionedCellMessage, keys),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "columns",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(VersionedCellMessage, n_columns),
    offsetof(VersionedCellMessage, columns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "blob",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(VersionedCellMessage, blob),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(VersionedCellMessage, version),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned versioned_cell_message__field_indices_by_name[] = {
  3,   /* field[3] = blob */
  2,   /* field[2] = columns */
  1,   /* field[1] = keys */
  0,   /* field[0] = table_key */
  4,   /* field[4] = version */
};
static const ProtobufCIntRange versioned_cell_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor versioned_cell_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "VersionedCellMessage",
  "VersionedCellMessage",
  "VersionedCellMessage",
  "",
  sizeof(VersionedCellMessage),
  5,
  versioned_cell_message__field_descriptors,
  versioned_cell_message__field_indices_by_name,
  1,  versioned_cell_message__number_ranges,
  (ProtobufCMessageInit) versioned_cell_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor server_message__field_descriptors[8] =
{
  {
    "mtype",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "wm",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, wm),
    &write_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rm",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, rm),
    &read_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rrm",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, rrm),
    &range_read_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "qm",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, qm),
    &queue_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tm",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, tm),
    &txn_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "gl",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, gl),
    &gossip_listen_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vc",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ServerMessage, vc),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned server_message__field_indices_by_name[] = {
  6,   /* field[6] = gl */
  0,   /* field[0] = mtype */
  4,   /* field[4] = qm */
  2,   /* field[2] = rm */
  3,   /* field[3] = rrm */
  5,   /* field[5] = tm */
  7,   /* field[7] = vc */
  1,   /* field[1] = wm */
};
static const ProtobufCIntRange server_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 8 }
};
const ProtobufCMessageDescriptor server_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ServerMessage",
  "ServerMessage",
  "ServerMessage",
  "",
  sizeof(ServerMessage),
  8,
  server_message__field_descriptors,
  server_message__field_indices_by_name,
  1,  server_message__number_ranges,
  (ProtobufCMessageInit) server_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor client_message__field_descriptors[7] =
{
  {
    "mtype",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "am",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, am),
    &ack_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "wm",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, wm),
    &write_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rrrm",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, rrrm),
    &range_read_response_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "qm",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, qm),
    &queue_query_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tm",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, tm),
    &txn_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vc",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ClientMessage, vc),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned client_message__field_indices_by_name[] = {
  1,   /* field[1] = am */
  0,   /* field[0] = mtype */
  4,   /* field[4] = qm */
  3,   /* field[3] = rrrm */
  5,   /* field[5] = tm */
  6,   /* field[6] = vc */
  2,   /* field[2] = wm */
};
static const ProtobufCIntRange client_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor client_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ClientMessage",
  "ClientMessage",
  "ClientMessage",
  "",
  sizeof(ClientMessage),
  7,
  client_message__field_descriptors,
  client_message__field_indices_by_name,
  1,  client_message__number_ranges,
  (ProtobufCMessageInit) client_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor write_query_message__field_descriptors[5] =
{
  {
    "cell",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(WriteQueryMessage, cell),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(WriteQueryMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(WriteQueryMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(WriteQueryMessage, msg_type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(WriteQueryMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned write_query_message__field_indices_by_name[] = {
  0,   /* field[0] = cell */
  3,   /* field[3] = msg_type */
  4,   /* field[4] = mtype */
  2,   /* field[2] = nonce */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange write_query_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor write_query_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "WriteQueryMessage",
  "WriteQueryMessage",
  "WriteQueryMessage",
  "",
  sizeof(WriteQueryMessage),
  5,
  write_query_message__field_descriptors,
  write_query_message__field_indices_by_name,
  1,  write_query_message__number_ranges,
  (ProtobufCMessageInit) write_query_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor read_query_message__field_descriptors[4] =
{
  {
    "cell_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ReadQueryMessage, cell_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(ReadQueryMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ReadQueryMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ReadQueryMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned read_query_message__field_indices_by_name[] = {
  0,   /* field[0] = cell_address */
  3,   /* field[3] = mtype */
  2,   /* field[2] = nonce */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange read_query_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor read_query_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ReadQueryMessage",
  "ReadQueryMessage",
  "ReadQueryMessage",
  "",
  sizeof(ReadQueryMessage),
  4,
  read_query_message__field_descriptors,
  read_query_message__field_indices_by_name,
  1,  read_query_message__number_ranges,
  (ProtobufCMessageInit) read_query_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor ack_message__field_descriptors[5] =
{
  {
    "cell_address",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(AckMessage, cell_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "status",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(AckMessage, status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(AckMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(AckMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(AckMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned ack_message__field_indices_by_name[] = {
  0,   /* field[0] = cell_address */
  4,   /* field[4] = mtype */
  3,   /* field[3] = nonce */
  1,   /* field[1] = status */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange ack_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor ack_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "AckMessage",
  "AckMessage",
  "AckMessage",
  "",
  sizeof(AckMessage),
  5,
  ack_message__field_descriptors,
  ack_message__field_indices_by_name,
  1,  ack_message__number_ranges,
  (ProtobufCMessageInit) ack_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor range_read_query_message__field_descriptors[5] =
{
  {
    "start_cell_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(RangeReadQueryMessage, start_cell_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "end_cell_address",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(RangeReadQueryMessage, end_cell_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(RangeReadQueryMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(RangeReadQueryMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(RangeReadQueryMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned range_read_query_message__field_indices_by_name[] = {
  1,   /* field[1] = end_cell_address */
  4,   /* field[4] = mtype */
  3,   /* field[3] = nonce */
  0,   /* field[0] = start_cell_address */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange range_read_query_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor range_read_query_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "RangeReadQueryMessage",
  "RangeReadQueryMessage",
  "RangeReadQueryMessage",
  "",
  sizeof(RangeReadQueryMessage),
  5,
  range_read_query_message__field_descriptors,
  range_read_query_message__field_indices_by_name,
  1,  range_read_query_message__number_ranges,
  (ProtobufCMessageInit) range_read_query_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor range_read_response_message__field_descriptors[4] =
{
  {
    "cells",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(RangeReadResponseMessage, n_cells),
    offsetof(RangeReadResponseMessage, cells),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(RangeReadResponseMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(RangeReadResponseMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(RangeReadResponseMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned range_read_response_message__field_indices_by_name[] = {
  0,   /* field[0] = cells */
  3,   /* field[3] = mtype */
  2,   /* field[2] = nonce */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange range_read_response_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor range_read_response_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "RangeReadResponseMessage",
  "RangeReadResponseMessage",
  "RangeReadResponseMessage",
  "",
  sizeof(RangeReadResponseMessage),
  4,
  range_read_response_message__field_descriptors,
  range_read_response_message__field_indices_by_name,
  1,  range_read_response_message__number_ranges,
  (ProtobufCMessageInit) range_read_response_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor txn_message__field_descriptors[9] =
{
  {
    "type",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(TxnMessage, type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "own_read_set",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(TxnMessage, n_own_read_set),
    offsetof(TxnMessage, own_read_set),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "own_write_set",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(TxnMessage, n_own_write_set),
    offsetof(TxnMessage, own_write_set),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "complete_read_set",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(TxnMessage, n_complete_read_set),
    offsetof(TxnMessage, complete_read_set),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "complete_write_set",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(TxnMessage, n_complete_write_set),
    offsetof(TxnMessage, complete_write_set),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(TxnMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(TxnMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(TxnMessage, version),
    &vector_clock_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    9,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(TxnMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned txn_message__field_indices_by_name[] = {
  3,   /* field[3] = complete_read_set */
  4,   /* field[4] = complete_write_set */
  8,   /* field[8] = mtype */
  6,   /* field[6] = nonce */
  1,   /* field[1] = own_read_set */
  2,   /* field[2] = own_write_set */
  5,   /* field[5] = txnid */
  0,   /* field[0] = type */
  7,   /* field[7] = version */
};
static const ProtobufCIntRange txn_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 9 }
};
const ProtobufCMessageDescriptor txn_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "TxnMessage",
  "TxnMessage",
  "TxnMessage",
  "",
  sizeof(TxnMessage),
  9,
  txn_message__field_descriptors,
  txn_message__field_indices_by_name,
  1,  txn_message__number_ranges,
  (ProtobufCMessageInit) txn_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor queue_query_message__field_descriptors[12] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, msg_type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "app_id",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, app_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "shard_id",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, shard_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, consumer_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "group_id",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, group_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "queue_index",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, queue_index),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "status",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cells",
    9,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(QueueQueryMessage, n_cells),
    offsetof(QueueQueryMessage, cells),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    10,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    11,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtype",
    12,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(QueueQueryMessage, mtype),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned queue_query_message__field_indices_by_name[] = {
  2,   /* field[2] = app_id */
  8,   /* field[8] = cells */
  4,   /* field[4] = consumer_id */
  5,   /* field[5] = group_id */
  1,   /* field[1] = msg_type */
  11,   /* field[11] = mtype */
  10,   /* field[10] = nonce */
  0,   /* field[0] = queue_address */
  6,   /* field[6] = queue_index */
  3,   /* field[3] = shard_id */
  7,   /* field[7] = status */
  9,   /* field[9] = txnid */
};
static const ProtobufCIntRange queue_query_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 12 }
};
const ProtobufCMessageDescriptor queue_query_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "QueueQueryMessage",
  "QueueQueryMessage",
  "QueueQueryMessage",
  "",
  sizeof(QueueQueryMessage),
  12,
  queue_query_message__field_descriptors,
  queue_query_message__field_indices_by_name,
  1,  queue_query_message__number_ranges,
  (ProtobufCMessageInit) queue_query_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor consumer_id__field_descriptors[3] =
{
  {
    "app_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ConsumerID, app_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "shard_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ConsumerID, shard_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ConsumerID, consumer_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned consumer_id__field_indices_by_name[] = {
  0,   /* field[0] = app_id */
  2,   /* field[2] = consumer_id */
  1,   /* field[1] = shard_id */
};
static const ProtobufCIntRange consumer_id__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor consumer_id__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ConsumerID",
  "ConsumerID",
  "ConsumerID",
  "",
  sizeof(ConsumerID),
  3,
  consumer_id__field_descriptors,
  consumer_id__field_indices_by_name,
  1,  consumer_id__number_ranges,
  (ProtobufCMessageInit) consumer_id__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor create_queue_message__field_descriptors[3] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(CreateQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(CreateQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(CreateQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned create_queue_message__field_indices_by_name[] = {
  2,   /* field[2] = nonce */
  0,   /* field[0] = queue_address */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange create_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor create_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "CreateQueueMessage",
  "CreateQueueMessage",
  "CreateQueueMessage",
  "",
  sizeof(CreateQueueMessage),
  3,
  create_queue_message__field_descriptors,
  create_queue_message__field_indices_by_name,
  1,  create_queue_message__number_ranges,
  (ProtobufCMessageInit) create_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor delete_queue_message__field_descriptors[3] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(DeleteQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(DeleteQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(DeleteQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned delete_queue_message__field_indices_by_name[] = {
  2,   /* field[2] = nonce */
  0,   /* field[0] = queue_address */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange delete_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor delete_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "DeleteQueueMessage",
  "DeleteQueueMessage",
  "DeleteQueueMessage",
  "",
  sizeof(DeleteQueueMessage),
  3,
  delete_queue_message__field_descriptors,
  delete_queue_message__field_indices_by_name,
  1,  delete_queue_message__number_ranges,
  (ProtobufCMessageInit) delete_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor subscribe_queue_message__field_descriptors[4] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(SubscribeQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(SubscribeQueueMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SubscribeQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(SubscribeQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned subscribe_queue_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  3,   /* field[3] = nonce */
  0,   /* field[0] = queue_address */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange subscribe_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor subscribe_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "SubscribeQueueMessage",
  "SubscribeQueueMessage",
  "SubscribeQueueMessage",
  "",
  sizeof(SubscribeQueueMessage),
  4,
  subscribe_queue_message__field_descriptors,
  subscribe_queue_message__field_indices_by_name,
  1,  subscribe_queue_message__number_ranges,
  (ProtobufCMessageInit) subscribe_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor unsubscribe_queue_message__field_descriptors[4] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(UnsubscribeQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(UnsubscribeQueueMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(UnsubscribeQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(UnsubscribeQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned unsubscribe_queue_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  3,   /* field[3] = nonce */
  0,   /* field[0] = queue_address */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange unsubscribe_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor unsubscribe_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "UnsubscribeQueueMessage",
  "UnsubscribeQueueMessage",
  "UnsubscribeQueueMessage",
  "",
  sizeof(UnsubscribeQueueMessage),
  4,
  unsubscribe_queue_message__field_descriptors,
  unsubscribe_queue_message__field_indices_by_name,
  1,  unsubscribe_queue_message__number_ranges,
  (ProtobufCMessageInit) unsubscribe_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor enqueue_message__field_descriptors[3] =
{
  {
    "cells",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(EnqueueMessage, n_cells),
    offsetof(EnqueueMessage, cells),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(EnqueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(EnqueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned enqueue_message__field_indices_by_name[] = {
  0,   /* field[0] = cells */
  2,   /* field[2] = nonce */
  1,   /* field[1] = txnid */
};
static const ProtobufCIntRange enqueue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor enqueue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "EnqueueMessage",
  "EnqueueMessage",
  "EnqueueMessage",
  "",
  sizeof(EnqueueMessage),
  3,
  enqueue_message__field_descriptors,
  enqueue_message__field_indices_by_name,
  1,  enqueue_message__number_ranges,
  (ProtobufCMessageInit) enqueue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor enqueue_response_message__field_descriptors[4] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(EnqueueResponseMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "last_item_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(EnqueueResponseMessage, last_item_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(EnqueueResponseMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(EnqueueResponseMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned enqueue_response_message__field_indices_by_name[] = {
  1,   /* field[1] = last_item_id */
  3,   /* field[3] = nonce */
  0,   /* field[0] = queue_address */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange enqueue_response_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor enqueue_response_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "EnqueueResponseMessage",
  "EnqueueResponseMessage",
  "EnqueueResponseMessage",
  "",
  sizeof(EnqueueResponseMessage),
  4,
  enqueue_response_message__field_descriptors,
  enqueue_response_message__field_indices_by_name,
  1,  enqueue_response_message__number_ranges,
  (ProtobufCMessageInit) enqueue_response_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor read_queue_message__field_descriptors[5] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ReadQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ReadQueueMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "max_items",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ReadQueueMessage, max_items),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(ReadQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ReadQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned read_queue_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  2,   /* field[2] = max_items */
  4,   /* field[4] = nonce */
  0,   /* field[0] = queue_address */
  3,   /* field[3] = txnid */
};
static const ProtobufCIntRange read_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor read_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ReadQueueMessage",
  "ReadQueueMessage",
  "ReadQueueMessage",
  "",
  sizeof(ReadQueueMessage),
  5,
  read_queue_message__field_descriptors,
  read_queue_message__field_indices_by_name,
  1,  read_queue_message__number_ranges,
  (ProtobufCMessageInit) read_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor read_queue_response_message__field_descriptors[4] =
{
  {
    "queue_entries",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(ReadQueueResponseMessage, n_queue_entries),
    offsetof(ReadQueueResponseMessage, queue_entries),
    &versioned_cell_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ReadQueueResponseMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(ReadQueueResponseMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ReadQueueResponseMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned read_queue_response_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  3,   /* field[3] = nonce */
  0,   /* field[0] = queue_entries */
  2,   /* field[2] = txnid */
};
static const ProtobufCIntRange read_queue_response_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor read_queue_response_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ReadQueueResponseMessage",
  "ReadQueueResponseMessage",
  "ReadQueueResponseMessage",
  "",
  sizeof(ReadQueueResponseMessage),
  4,
  read_queue_response_message__field_descriptors,
  read_queue_response_message__field_indices_by_name,
  1,  read_queue_response_message__number_ranges,
  (ProtobufCMessageInit) read_queue_response_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor consume_queue_message__field_descriptors[5] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "new_consume_head",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueMessage, new_consume_head),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned consume_queue_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  2,   /* field[2] = new_consume_head */
  4,   /* field[4] = nonce */
  0,   /* field[0] = queue_address */
  3,   /* field[3] = txnid */
};
static const ProtobufCIntRange consume_queue_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor consume_queue_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ConsumeQueueMessage",
  "ConsumeQueueMessage",
  "ConsumeQueueMessage",
  "",
  sizeof(ConsumeQueueMessage),
  5,
  consume_queue_message__field_descriptors,
  consume_queue_message__field_indices_by_name,
  1,  consume_queue_message__number_ranges,
  (ProtobufCMessageInit) consume_queue_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor consume_queue_response_message__field_descriptors[6] =
{
  {
    "queue_address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, queue_address),
    &cell_address_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "consumer_id",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, consumer_id),
    &consumer_id__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "status",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "new_consume_head",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, new_consume_head),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "txnid",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, txnid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nonce",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(ConsumeQueueResponseMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned consume_queue_response_message__field_indices_by_name[] = {
  1,   /* field[1] = consumer_id */
  3,   /* field[3] = new_consume_head */
  5,   /* field[5] = nonce */
  0,   /* field[0] = queue_address */
  2,   /* field[2] = status */
  4,   /* field[4] = txnid */
};
static const ProtobufCIntRange consume_queue_response_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor consume_queue_response_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ConsumeQueueResponseMessage",
  "ConsumeQueueResponseMessage",
  "ConsumeQueueResponseMessage",
  "",
  sizeof(ConsumeQueueResponseMessage),
  6,
  consume_queue_response_message__field_descriptors,
  consume_queue_response_message__field_indices_by_name,
  1,  consume_queue_response_message__number_ranges,
  (ProtobufCMessageInit) consume_queue_response_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
