/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: gossip/message.proto */

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

#include "gossip/message.pb-c.h"
void   gossip__envelope__init
                     (Gossip__Envelope         *message)
{
  static Gossip__Envelope init_value = GOSSIP__ENVELOPE__INIT;
  *message = init_value;
}
size_t gossip__envelope__get_packed_size
                     (const Gossip__Envelope *message)
{
  assert(message->base.descriptor == &gossip__envelope__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__envelope__pack
                     (const Gossip__Envelope *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__envelope__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__envelope__pack_to_buffer
                     (const Gossip__Envelope *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__envelope__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Envelope *
       gossip__envelope__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Envelope *)
     protobuf_c_message_unpack (&gossip__envelope__descriptor,
                                allocator, len, data);
}
void   gossip__envelope__free_unpacked
                     (Gossip__Envelope *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__envelope__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__secret_envelope__init
                     (Gossip__SecretEnvelope         *message)
{
  static Gossip__SecretEnvelope init_value = GOSSIP__SECRET_ENVELOPE__INIT;
  *message = init_value;
}
size_t gossip__secret_envelope__get_packed_size
                     (const Gossip__SecretEnvelope *message)
{
  assert(message->base.descriptor == &gossip__secret_envelope__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__secret_envelope__pack
                     (const Gossip__SecretEnvelope *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__secret_envelope__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__secret_envelope__pack_to_buffer
                     (const Gossip__SecretEnvelope *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__secret_envelope__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__SecretEnvelope *
       gossip__secret_envelope__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__SecretEnvelope *)
     protobuf_c_message_unpack (&gossip__secret_envelope__descriptor,
                                allocator, len, data);
}
void   gossip__secret_envelope__free_unpacked
                     (Gossip__SecretEnvelope *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__secret_envelope__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__secret__init
                     (Gossip__Secret         *message)
{
  static Gossip__Secret init_value = GOSSIP__SECRET__INIT;
  *message = init_value;
}
size_t gossip__secret__get_packed_size
                     (const Gossip__Secret *message)
{
  assert(message->base.descriptor == &gossip__secret__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__secret__pack
                     (const Gossip__Secret *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__secret__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__secret__pack_to_buffer
                     (const Gossip__Secret *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__secret__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Secret *
       gossip__secret__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Secret *)
     protobuf_c_message_unpack (&gossip__secret__descriptor,
                                allocator, len, data);
}
void   gossip__secret__free_unpacked
                     (Gossip__Secret *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__secret__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__gossip_message__init
                     (Gossip__GossipMessage         *message)
{
  static Gossip__GossipMessage init_value = GOSSIP__GOSSIP_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip__gossip_message__get_packed_size
                     (const Gossip__GossipMessage *message)
{
  assert(message->base.descriptor == &gossip__gossip_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__gossip_message__pack
                     (const Gossip__GossipMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__gossip_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__gossip_message__pack_to_buffer
                     (const Gossip__GossipMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__gossip_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__GossipMessage *
       gossip__gossip_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__GossipMessage *)
     protobuf_c_message_unpack (&gossip__gossip_message__descriptor,
                                allocator, len, data);
}
void   gossip__gossip_message__free_unpacked
                     (Gossip__GossipMessage *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__gossip_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__state_info__init
                     (Gossip__StateInfo         *message)
{
  static Gossip__StateInfo init_value = GOSSIP__STATE_INFO__INIT;
  *message = init_value;
}
size_t gossip__state_info__get_packed_size
                     (const Gossip__StateInfo *message)
{
  assert(message->base.descriptor == &gossip__state_info__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__state_info__pack
                     (const Gossip__StateInfo *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__state_info__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__state_info__pack_to_buffer
                     (const Gossip__StateInfo *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__state_info__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__StateInfo *
       gossip__state_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__StateInfo *)
     protobuf_c_message_unpack (&gossip__state_info__descriptor,
                                allocator, len, data);
}
void   gossip__state_info__free_unpacked
                     (Gossip__StateInfo *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__state_info__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__properties__init
                     (Gossip__Properties         *message)
{
  static Gossip__Properties init_value = GOSSIP__PROPERTIES__INIT;
  *message = init_value;
}
size_t gossip__properties__get_packed_size
                     (const Gossip__Properties *message)
{
  assert(message->base.descriptor == &gossip__properties__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__properties__pack
                     (const Gossip__Properties *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__properties__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__properties__pack_to_buffer
                     (const Gossip__Properties *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__properties__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Properties *
       gossip__properties__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Properties *)
     protobuf_c_message_unpack (&gossip__properties__descriptor,
                                allocator, len, data);
}
void   gossip__properties__free_unpacked
                     (Gossip__Properties *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__properties__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__state_info_snapshot__init
                     (Gossip__StateInfoSnapshot         *message)
{
  static Gossip__StateInfoSnapshot init_value = GOSSIP__STATE_INFO_SNAPSHOT__INIT;
  *message = init_value;
}
size_t gossip__state_info_snapshot__get_packed_size
                     (const Gossip__StateInfoSnapshot *message)
{
  assert(message->base.descriptor == &gossip__state_info_snapshot__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__state_info_snapshot__pack
                     (const Gossip__StateInfoSnapshot *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__state_info_snapshot__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__state_info_snapshot__pack_to_buffer
                     (const Gossip__StateInfoSnapshot *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__state_info_snapshot__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__StateInfoSnapshot *
       gossip__state_info_snapshot__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__StateInfoSnapshot *)
     protobuf_c_message_unpack (&gossip__state_info_snapshot__descriptor,
                                allocator, len, data);
}
void   gossip__state_info_snapshot__free_unpacked
                     (Gossip__StateInfoSnapshot *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__state_info_snapshot__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__state_info_pull_request__init
                     (Gossip__StateInfoPullRequest         *message)
{
  static Gossip__StateInfoPullRequest init_value = GOSSIP__STATE_INFO_PULL_REQUEST__INIT;
  *message = init_value;
}
size_t gossip__state_info_pull_request__get_packed_size
                     (const Gossip__StateInfoPullRequest *message)
{
  assert(message->base.descriptor == &gossip__state_info_pull_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__state_info_pull_request__pack
                     (const Gossip__StateInfoPullRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__state_info_pull_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__state_info_pull_request__pack_to_buffer
                     (const Gossip__StateInfoPullRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__state_info_pull_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__StateInfoPullRequest *
       gossip__state_info_pull_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__StateInfoPullRequest *)
     protobuf_c_message_unpack (&gossip__state_info_pull_request__descriptor,
                                allocator, len, data);
}
void   gossip__state_info_pull_request__free_unpacked
                     (Gossip__StateInfoPullRequest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__state_info_pull_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__conn_establish__init
                     (Gossip__ConnEstablish         *message)
{
  static Gossip__ConnEstablish init_value = GOSSIP__CONN_ESTABLISH__INIT;
  *message = init_value;
}
size_t gossip__conn_establish__get_packed_size
                     (const Gossip__ConnEstablish *message)
{
  assert(message->base.descriptor == &gossip__conn_establish__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__conn_establish__pack
                     (const Gossip__ConnEstablish *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__conn_establish__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__conn_establish__pack_to_buffer
                     (const Gossip__ConnEstablish *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__conn_establish__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__ConnEstablish *
       gossip__conn_establish__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__ConnEstablish *)
     protobuf_c_message_unpack (&gossip__conn_establish__descriptor,
                                allocator, len, data);
}
void   gossip__conn_establish__free_unpacked
                     (Gossip__ConnEstablish *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__conn_establish__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__peer_identity__init
                     (Gossip__PeerIdentity         *message)
{
  static Gossip__PeerIdentity init_value = GOSSIP__PEER_IDENTITY__INIT;
  *message = init_value;
}
size_t gossip__peer_identity__get_packed_size
                     (const Gossip__PeerIdentity *message)
{
  assert(message->base.descriptor == &gossip__peer_identity__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__peer_identity__pack
                     (const Gossip__PeerIdentity *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__peer_identity__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__peer_identity__pack_to_buffer
                     (const Gossip__PeerIdentity *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__peer_identity__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PeerIdentity *
       gossip__peer_identity__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PeerIdentity *)
     protobuf_c_message_unpack (&gossip__peer_identity__descriptor,
                                allocator, len, data);
}
void   gossip__peer_identity__free_unpacked
                     (Gossip__PeerIdentity *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__peer_identity__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__data_request__init
                     (Gossip__DataRequest         *message)
{
  static Gossip__DataRequest init_value = GOSSIP__DATA_REQUEST__INIT;
  *message = init_value;
}
size_t gossip__data_request__get_packed_size
                     (const Gossip__DataRequest *message)
{
  assert(message->base.descriptor == &gossip__data_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__data_request__pack
                     (const Gossip__DataRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__data_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__data_request__pack_to_buffer
                     (const Gossip__DataRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__data_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__DataRequest *
       gossip__data_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__DataRequest *)
     protobuf_c_message_unpack (&gossip__data_request__descriptor,
                                allocator, len, data);
}
void   gossip__data_request__free_unpacked
                     (Gossip__DataRequest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__data_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__gossip_hello__init
                     (Gossip__GossipHello         *message)
{
  static Gossip__GossipHello init_value = GOSSIP__GOSSIP_HELLO__INIT;
  *message = init_value;
}
size_t gossip__gossip_hello__get_packed_size
                     (const Gossip__GossipHello *message)
{
  assert(message->base.descriptor == &gossip__gossip_hello__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__gossip_hello__pack
                     (const Gossip__GossipHello *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__gossip_hello__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__gossip_hello__pack_to_buffer
                     (const Gossip__GossipHello *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__gossip_hello__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__GossipHello *
       gossip__gossip_hello__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__GossipHello *)
     protobuf_c_message_unpack (&gossip__gossip_hello__descriptor,
                                allocator, len, data);
}
void   gossip__gossip_hello__free_unpacked
                     (Gossip__GossipHello *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__gossip_hello__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__data_update__init
                     (Gossip__DataUpdate         *message)
{
  static Gossip__DataUpdate init_value = GOSSIP__DATA_UPDATE__INIT;
  *message = init_value;
}
size_t gossip__data_update__get_packed_size
                     (const Gossip__DataUpdate *message)
{
  assert(message->base.descriptor == &gossip__data_update__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__data_update__pack
                     (const Gossip__DataUpdate *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__data_update__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__data_update__pack_to_buffer
                     (const Gossip__DataUpdate *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__data_update__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__DataUpdate *
       gossip__data_update__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__DataUpdate *)
     protobuf_c_message_unpack (&gossip__data_update__descriptor,
                                allocator, len, data);
}
void   gossip__data_update__free_unpacked
                     (Gossip__DataUpdate *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__data_update__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__data_digest__init
                     (Gossip__DataDigest         *message)
{
  static Gossip__DataDigest init_value = GOSSIP__DATA_DIGEST__INIT;
  *message = init_value;
}
size_t gossip__data_digest__get_packed_size
                     (const Gossip__DataDigest *message)
{
  assert(message->base.descriptor == &gossip__data_digest__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__data_digest__pack
                     (const Gossip__DataDigest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__data_digest__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__data_digest__pack_to_buffer
                     (const Gossip__DataDigest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__data_digest__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__DataDigest *
       gossip__data_digest__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__DataDigest *)
     protobuf_c_message_unpack (&gossip__data_digest__descriptor,
                                allocator, len, data);
}
void   gossip__data_digest__free_unpacked
                     (Gossip__DataDigest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__data_digest__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__data_message__init
                     (Gossip__DataMessage         *message)
{
  static Gossip__DataMessage init_value = GOSSIP__DATA_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip__data_message__get_packed_size
                     (const Gossip__DataMessage *message)
{
  assert(message->base.descriptor == &gossip__data_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__data_message__pack
                     (const Gossip__DataMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__data_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__data_message__pack_to_buffer
                     (const Gossip__DataMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__data_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__DataMessage *
       gossip__data_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__DataMessage *)
     protobuf_c_message_unpack (&gossip__data_message__descriptor,
                                allocator, len, data);
}
void   gossip__data_message__free_unpacked
                     (Gossip__DataMessage *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__data_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__private_data_message__init
                     (Gossip__PrivateDataMessage         *message)
{
  static Gossip__PrivateDataMessage init_value = GOSSIP__PRIVATE_DATA_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip__private_data_message__get_packed_size
                     (const Gossip__PrivateDataMessage *message)
{
  assert(message->base.descriptor == &gossip__private_data_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__private_data_message__pack
                     (const Gossip__PrivateDataMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__private_data_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__private_data_message__pack_to_buffer
                     (const Gossip__PrivateDataMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__private_data_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PrivateDataMessage *
       gossip__private_data_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PrivateDataMessage *)
     protobuf_c_message_unpack (&gossip__private_data_message__descriptor,
                                allocator, len, data);
}
void   gossip__private_data_message__free_unpacked
                     (Gossip__PrivateDataMessage *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__private_data_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__payload__init
                     (Gossip__Payload         *message)
{
  static Gossip__Payload init_value = GOSSIP__PAYLOAD__INIT;
  *message = init_value;
}
size_t gossip__payload__get_packed_size
                     (const Gossip__Payload *message)
{
  assert(message->base.descriptor == &gossip__payload__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__payload__pack
                     (const Gossip__Payload *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__payload__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__payload__pack_to_buffer
                     (const Gossip__Payload *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__payload__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Payload *
       gossip__payload__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Payload *)
     protobuf_c_message_unpack (&gossip__payload__descriptor,
                                allocator, len, data);
}
void   gossip__payload__free_unpacked
                     (Gossip__Payload *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__payload__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__private_payload__init
                     (Gossip__PrivatePayload         *message)
{
  static Gossip__PrivatePayload init_value = GOSSIP__PRIVATE_PAYLOAD__INIT;
  *message = init_value;
}
size_t gossip__private_payload__get_packed_size
                     (const Gossip__PrivatePayload *message)
{
  assert(message->base.descriptor == &gossip__private_payload__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__private_payload__pack
                     (const Gossip__PrivatePayload *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__private_payload__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__private_payload__pack_to_buffer
                     (const Gossip__PrivatePayload *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__private_payload__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PrivatePayload *
       gossip__private_payload__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PrivatePayload *)
     protobuf_c_message_unpack (&gossip__private_payload__descriptor,
                                allocator, len, data);
}
void   gossip__private_payload__free_unpacked
                     (Gossip__PrivatePayload *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__private_payload__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__alive_message__init
                     (Gossip__AliveMessage         *message)
{
  static Gossip__AliveMessage init_value = GOSSIP__ALIVE_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip__alive_message__get_packed_size
                     (const Gossip__AliveMessage *message)
{
  assert(message->base.descriptor == &gossip__alive_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__alive_message__pack
                     (const Gossip__AliveMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__alive_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__alive_message__pack_to_buffer
                     (const Gossip__AliveMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__alive_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__AliveMessage *
       gossip__alive_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__AliveMessage *)
     protobuf_c_message_unpack (&gossip__alive_message__descriptor,
                                allocator, len, data);
}
void   gossip__alive_message__free_unpacked
                     (Gossip__AliveMessage *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__alive_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__leadership_message__init
                     (Gossip__LeadershipMessage         *message)
{
  static Gossip__LeadershipMessage init_value = GOSSIP__LEADERSHIP_MESSAGE__INIT;
  *message = init_value;
}
size_t gossip__leadership_message__get_packed_size
                     (const Gossip__LeadershipMessage *message)
{
  assert(message->base.descriptor == &gossip__leadership_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__leadership_message__pack
                     (const Gossip__LeadershipMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__leadership_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__leadership_message__pack_to_buffer
                     (const Gossip__LeadershipMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__leadership_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__LeadershipMessage *
       gossip__leadership_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__LeadershipMessage *)
     protobuf_c_message_unpack (&gossip__leadership_message__descriptor,
                                allocator, len, data);
}
void   gossip__leadership_message__free_unpacked
                     (Gossip__LeadershipMessage *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__leadership_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__peer_time__init
                     (Gossip__PeerTime         *message)
{
  static Gossip__PeerTime init_value = GOSSIP__PEER_TIME__INIT;
  *message = init_value;
}
size_t gossip__peer_time__get_packed_size
                     (const Gossip__PeerTime *message)
{
  assert(message->base.descriptor == &gossip__peer_time__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__peer_time__pack
                     (const Gossip__PeerTime *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__peer_time__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__peer_time__pack_to_buffer
                     (const Gossip__PeerTime *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__peer_time__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PeerTime *
       gossip__peer_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PeerTime *)
     protobuf_c_message_unpack (&gossip__peer_time__descriptor,
                                allocator, len, data);
}
void   gossip__peer_time__free_unpacked
                     (Gossip__PeerTime *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__peer_time__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__membership_request__init
                     (Gossip__MembershipRequest         *message)
{
  static Gossip__MembershipRequest init_value = GOSSIP__MEMBERSHIP_REQUEST__INIT;
  *message = init_value;
}
size_t gossip__membership_request__get_packed_size
                     (const Gossip__MembershipRequest *message)
{
  assert(message->base.descriptor == &gossip__membership_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__membership_request__pack
                     (const Gossip__MembershipRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__membership_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__membership_request__pack_to_buffer
                     (const Gossip__MembershipRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__membership_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__MembershipRequest *
       gossip__membership_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__MembershipRequest *)
     protobuf_c_message_unpack (&gossip__membership_request__descriptor,
                                allocator, len, data);
}
void   gossip__membership_request__free_unpacked
                     (Gossip__MembershipRequest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__membership_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__membership_response__init
                     (Gossip__MembershipResponse         *message)
{
  static Gossip__MembershipResponse init_value = GOSSIP__MEMBERSHIP_RESPONSE__INIT;
  *message = init_value;
}
size_t gossip__membership_response__get_packed_size
                     (const Gossip__MembershipResponse *message)
{
  assert(message->base.descriptor == &gossip__membership_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__membership_response__pack
                     (const Gossip__MembershipResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__membership_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__membership_response__pack_to_buffer
                     (const Gossip__MembershipResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__membership_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__MembershipResponse *
       gossip__membership_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__MembershipResponse *)
     protobuf_c_message_unpack (&gossip__membership_response__descriptor,
                                allocator, len, data);
}
void   gossip__membership_response__free_unpacked
                     (Gossip__MembershipResponse *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__membership_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__member__init
                     (Gossip__Member         *message)
{
  static Gossip__Member init_value = GOSSIP__MEMBER__INIT;
  *message = init_value;
}
size_t gossip__member__get_packed_size
                     (const Gossip__Member *message)
{
  assert(message->base.descriptor == &gossip__member__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__member__pack
                     (const Gossip__Member *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__member__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__member__pack_to_buffer
                     (const Gossip__Member *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__member__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Member *
       gossip__member__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Member *)
     protobuf_c_message_unpack (&gossip__member__descriptor,
                                allocator, len, data);
}
void   gossip__member__free_unpacked
                     (Gossip__Member *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__member__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__empty__init
                     (Gossip__Empty         *message)
{
  static Gossip__Empty init_value = GOSSIP__EMPTY__INIT;
  *message = init_value;
}
size_t gossip__empty__get_packed_size
                     (const Gossip__Empty *message)
{
  assert(message->base.descriptor == &gossip__empty__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__empty__pack
                     (const Gossip__Empty *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__empty__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__empty__pack_to_buffer
                     (const Gossip__Empty *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__empty__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Empty *
       gossip__empty__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Empty *)
     protobuf_c_message_unpack (&gossip__empty__descriptor,
                                allocator, len, data);
}
void   gossip__empty__free_unpacked
                     (Gossip__Empty *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__empty__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__remote_state_request__init
                     (Gossip__RemoteStateRequest         *message)
{
  static Gossip__RemoteStateRequest init_value = GOSSIP__REMOTE_STATE_REQUEST__INIT;
  *message = init_value;
}
size_t gossip__remote_state_request__get_packed_size
                     (const Gossip__RemoteStateRequest *message)
{
  assert(message->base.descriptor == &gossip__remote_state_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__remote_state_request__pack
                     (const Gossip__RemoteStateRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__remote_state_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__remote_state_request__pack_to_buffer
                     (const Gossip__RemoteStateRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__remote_state_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__RemoteStateRequest *
       gossip__remote_state_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__RemoteStateRequest *)
     protobuf_c_message_unpack (&gossip__remote_state_request__descriptor,
                                allocator, len, data);
}
void   gossip__remote_state_request__free_unpacked
                     (Gossip__RemoteStateRequest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__remote_state_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__remote_state_response__init
                     (Gossip__RemoteStateResponse         *message)
{
  static Gossip__RemoteStateResponse init_value = GOSSIP__REMOTE_STATE_RESPONSE__INIT;
  *message = init_value;
}
size_t gossip__remote_state_response__get_packed_size
                     (const Gossip__RemoteStateResponse *message)
{
  assert(message->base.descriptor == &gossip__remote_state_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__remote_state_response__pack
                     (const Gossip__RemoteStateResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__remote_state_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__remote_state_response__pack_to_buffer
                     (const Gossip__RemoteStateResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__remote_state_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__RemoteStateResponse *
       gossip__remote_state_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__RemoteStateResponse *)
     protobuf_c_message_unpack (&gossip__remote_state_response__descriptor,
                                allocator, len, data);
}
void   gossip__remote_state_response__free_unpacked
                     (Gossip__RemoteStateResponse *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__remote_state_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__remote_pvt_data_request__init
                     (Gossip__RemotePvtDataRequest         *message)
{
  static Gossip__RemotePvtDataRequest init_value = GOSSIP__REMOTE_PVT_DATA_REQUEST__INIT;
  *message = init_value;
}
size_t gossip__remote_pvt_data_request__get_packed_size
                     (const Gossip__RemotePvtDataRequest *message)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__remote_pvt_data_request__pack
                     (const Gossip__RemotePvtDataRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__remote_pvt_data_request__pack_to_buffer
                     (const Gossip__RemotePvtDataRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__RemotePvtDataRequest *
       gossip__remote_pvt_data_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__RemotePvtDataRequest *)
     protobuf_c_message_unpack (&gossip__remote_pvt_data_request__descriptor,
                                allocator, len, data);
}
void   gossip__remote_pvt_data_request__free_unpacked
                     (Gossip__RemotePvtDataRequest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__pvt_data_digest__init
                     (Gossip__PvtDataDigest         *message)
{
  static Gossip__PvtDataDigest init_value = GOSSIP__PVT_DATA_DIGEST__INIT;
  *message = init_value;
}
size_t gossip__pvt_data_digest__get_packed_size
                     (const Gossip__PvtDataDigest *message)
{
  assert(message->base.descriptor == &gossip__pvt_data_digest__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__pvt_data_digest__pack
                     (const Gossip__PvtDataDigest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__pvt_data_digest__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__pvt_data_digest__pack_to_buffer
                     (const Gossip__PvtDataDigest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__pvt_data_digest__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PvtDataDigest *
       gossip__pvt_data_digest__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PvtDataDigest *)
     protobuf_c_message_unpack (&gossip__pvt_data_digest__descriptor,
                                allocator, len, data);
}
void   gossip__pvt_data_digest__free_unpacked
                     (Gossip__PvtDataDigest *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__pvt_data_digest__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__remote_pvt_data_response__init
                     (Gossip__RemotePvtDataResponse         *message)
{
  static Gossip__RemotePvtDataResponse init_value = GOSSIP__REMOTE_PVT_DATA_RESPONSE__INIT;
  *message = init_value;
}
size_t gossip__remote_pvt_data_response__get_packed_size
                     (const Gossip__RemotePvtDataResponse *message)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__remote_pvt_data_response__pack
                     (const Gossip__RemotePvtDataResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__remote_pvt_data_response__pack_to_buffer
                     (const Gossip__RemotePvtDataResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__RemotePvtDataResponse *
       gossip__remote_pvt_data_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__RemotePvtDataResponse *)
     protobuf_c_message_unpack (&gossip__remote_pvt_data_response__descriptor,
                                allocator, len, data);
}
void   gossip__remote_pvt_data_response__free_unpacked
                     (Gossip__RemotePvtDataResponse *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__remote_pvt_data_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__pvt_data_element__init
                     (Gossip__PvtDataElement         *message)
{
  static Gossip__PvtDataElement init_value = GOSSIP__PVT_DATA_ELEMENT__INIT;
  *message = init_value;
}
size_t gossip__pvt_data_element__get_packed_size
                     (const Gossip__PvtDataElement *message)
{
  assert(message->base.descriptor == &gossip__pvt_data_element__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__pvt_data_element__pack
                     (const Gossip__PvtDataElement *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__pvt_data_element__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__pvt_data_element__pack_to_buffer
                     (const Gossip__PvtDataElement *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__pvt_data_element__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PvtDataElement *
       gossip__pvt_data_element__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PvtDataElement *)
     protobuf_c_message_unpack (&gossip__pvt_data_element__descriptor,
                                allocator, len, data);
}
void   gossip__pvt_data_element__free_unpacked
                     (Gossip__PvtDataElement *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__pvt_data_element__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__pvt_data_payload__init
                     (Gossip__PvtDataPayload         *message)
{
  static Gossip__PvtDataPayload init_value = GOSSIP__PVT_DATA_PAYLOAD__INIT;
  *message = init_value;
}
size_t gossip__pvt_data_payload__get_packed_size
                     (const Gossip__PvtDataPayload *message)
{
  assert(message->base.descriptor == &gossip__pvt_data_payload__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__pvt_data_payload__pack
                     (const Gossip__PvtDataPayload *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__pvt_data_payload__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__pvt_data_payload__pack_to_buffer
                     (const Gossip__PvtDataPayload *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__pvt_data_payload__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__PvtDataPayload *
       gossip__pvt_data_payload__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__PvtDataPayload *)
     protobuf_c_message_unpack (&gossip__pvt_data_payload__descriptor,
                                allocator, len, data);
}
void   gossip__pvt_data_payload__free_unpacked
                     (Gossip__PvtDataPayload *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__pvt_data_payload__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__acknowledgement__init
                     (Gossip__Acknowledgement         *message)
{
  static Gossip__Acknowledgement init_value = GOSSIP__ACKNOWLEDGEMENT__INIT;
  *message = init_value;
}
size_t gossip__acknowledgement__get_packed_size
                     (const Gossip__Acknowledgement *message)
{
  assert(message->base.descriptor == &gossip__acknowledgement__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__acknowledgement__pack
                     (const Gossip__Acknowledgement *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__acknowledgement__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__acknowledgement__pack_to_buffer
                     (const Gossip__Acknowledgement *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__acknowledgement__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Acknowledgement *
       gossip__acknowledgement__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Acknowledgement *)
     protobuf_c_message_unpack (&gossip__acknowledgement__descriptor,
                                allocator, len, data);
}
void   gossip__acknowledgement__free_unpacked
                     (Gossip__Acknowledgement *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__acknowledgement__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   gossip__chaincode__init
                     (Gossip__Chaincode         *message)
{
  static Gossip__Chaincode init_value = GOSSIP__CHAINCODE__INIT;
  *message = init_value;
}
size_t gossip__chaincode__get_packed_size
                     (const Gossip__Chaincode *message)
{
  assert(message->base.descriptor == &gossip__chaincode__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t gossip__chaincode__pack
                     (const Gossip__Chaincode *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &gossip__chaincode__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t gossip__chaincode__pack_to_buffer
                     (const Gossip__Chaincode *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &gossip__chaincode__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Gossip__Chaincode *
       gossip__chaincode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Gossip__Chaincode *)
     protobuf_c_message_unpack (&gossip__chaincode__descriptor,
                                allocator, len, data);
}
void   gossip__chaincode__free_unpacked
                     (Gossip__Chaincode *message,
                      ProtobufCAllocator *allocator)
{
  assert(message->base.descriptor == &gossip__chaincode__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
static const ProtobufCFieldDescriptor gossip__envelope__field_descriptors[3] =
{
  {
    "payload",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Envelope, has_payload),
    offsetof(Gossip__Envelope, payload),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "signature",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Envelope, has_signature),
    offsetof(Gossip__Envelope, signature),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secret_envelope",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__Envelope, secret_envelope),
    &gossip__secret_envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__envelope__field_indices_by_name[] = {
  0,   /* field[0] = payload */
  2,   /* field[2] = secret_envelope */
  1,   /* field[1] = signature */
};
static const ProtobufCIntRange gossip__envelope__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__envelope__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Envelope",
  "Envelope",
  "Gossip__Envelope",
  "gossip",
  sizeof(Gossip__Envelope),
  3,
  gossip__envelope__field_descriptors,
  gossip__envelope__field_indices_by_name,
  1,  gossip__envelope__number_ranges,
  (ProtobufCMessageInit) gossip__envelope__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__secret_envelope__field_descriptors[2] =
{
  {
    "payload",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__SecretEnvelope, has_payload),
    offsetof(Gossip__SecretEnvelope, payload),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "signature",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__SecretEnvelope, has_signature),
    offsetof(Gossip__SecretEnvelope, signature),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__secret_envelope__field_indices_by_name[] = {
  0,   /* field[0] = payload */
  1,   /* field[1] = signature */
};
static const ProtobufCIntRange gossip__secret_envelope__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__secret_envelope__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.SecretEnvelope",
  "SecretEnvelope",
  "Gossip__SecretEnvelope",
  "gossip",
  sizeof(Gossip__SecretEnvelope),
  2,
  gossip__secret_envelope__field_descriptors,
  gossip__secret_envelope__field_indices_by_name,
  1,  gossip__secret_envelope__number_ranges,
  (ProtobufCMessageInit) gossip__secret_envelope__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__secret__field_descriptors[1] =
{
  {
    "internalEndpoint",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Gossip__Secret, content_case),
    offsetof(Gossip__Secret, internalendpoint),
    NULL,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__secret__field_indices_by_name[] = {
  0,   /* field[0] = internalEndpoint */
};
static const ProtobufCIntRange gossip__secret__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__secret__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Secret",
  "Secret",
  "Gossip__Secret",
  "gossip",
  sizeof(Gossip__Secret),
  1,
  gossip__secret__field_descriptors,
  gossip__secret__field_indices_by_name,
  1,  gossip__secret__number_ranges,
  (ProtobufCMessageInit) gossip__secret__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue gossip__gossip_message__tag__enum_values_by_number[6] =
{
  { "UNDEFINED", "GOSSIP__GOSSIP_MESSAGE__TAG__UNDEFINED", 0 },
  { "EMPTY", "GOSSIP__GOSSIP_MESSAGE__TAG__EMPTY", 1 },
  { "ORG_ONLY", "GOSSIP__GOSSIP_MESSAGE__TAG__ORG_ONLY", 2 },
  { "CHAN_ONLY", "GOSSIP__GOSSIP_MESSAGE__TAG__CHAN_ONLY", 3 },
  { "CHAN_AND_ORG", "GOSSIP__GOSSIP_MESSAGE__TAG__CHAN_AND_ORG", 4 },
  { "CHAN_OR_ORG", "GOSSIP__GOSSIP_MESSAGE__TAG__CHAN_OR_ORG", 5 },
};
static const ProtobufCIntRange gossip__gossip_message__tag__value_ranges[] = {
{0, 0},{0, 6}
};
static const ProtobufCEnumValueIndex gossip__gossip_message__tag__enum_values_by_name[6] =
{
  { "CHAN_AND_ORG", 4 },
  { "CHAN_ONLY", 3 },
  { "CHAN_OR_ORG", 5 },
  { "EMPTY", 1 },
  { "ORG_ONLY", 2 },
  { "UNDEFINED", 0 },
};
const ProtobufCEnumDescriptor gossip__gossip_message__tag__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "gossip.GossipMessage.Tag",
  "Tag",
  "Gossip__GossipMessage__Tag",
  "gossip",
  6,
  gossip__gossip_message__tag__enum_values_by_number,
  6,
  gossip__gossip_message__tag__enum_values_by_name,
  1,
  gossip__gossip_message__tag__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor gossip__gossip_message__field_descriptors[24] =
{
  {
    "nonce",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__GossipMessage, has_nonce),
    offsetof(Gossip__GossipMessage, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__GossipMessage, has_channel),
    offsetof(Gossip__GossipMessage, channel),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tag",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Gossip__GossipMessage, has_tag),
    offsetof(Gossip__GossipMessage, tag),
    &gossip__gossip_message__tag__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "alive_msg",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, alive_msg),
    &gossip__alive_message__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mem_req",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, mem_req),
    &gossip__membership_request__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mem_res",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, mem_res),
    &gossip__membership_response__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data_msg",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, data_msg),
    &gossip__data_message__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hello",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, hello),
    &gossip__gossip_hello__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data_dig",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, data_dig),
    &gossip__data_digest__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data_req",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, data_req),
    &gossip__data_request__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data_update",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, data_update),
    &gossip__data_update__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "empty",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, empty),
    &gossip__empty__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "conn",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, conn),
    &gossip__conn_establish__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "state_info",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, state_info),
    &gossip__state_info__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "state_snapshot",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, state_snapshot),
    &gossip__state_info_snapshot__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "state_info_pull_req",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, state_info_pull_req),
    &gossip__state_info_pull_request__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "state_request",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, state_request),
    &gossip__remote_state_request__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "state_response",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, state_response),
    &gossip__remote_state_response__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "leadership_msg",
    20,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, leadership_msg),
    &gossip__leadership_message__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "peer_identity",
    21,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, peer_identity),
    &gossip__peer_identity__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ack",
    22,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, ack),
    &gossip__acknowledgement__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "privateReq",
    23,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, privatereq),
    &gossip__remote_pvt_data_request__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "privateRes",
    24,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, privateres),
    &gossip__remote_pvt_data_response__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "private_data",
    25,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__GossipMessage, content_case),
    offsetof(Gossip__GossipMessage, private_data),
    &gossip__private_data_message__descriptor,
    NULL,
    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__gossip_message__field_indices_by_name[] = {
  20,   /* field[20] = ack */
  3,   /* field[3] = alive_msg */
  1,   /* field[1] = channel */
  12,   /* field[12] = conn */
  8,   /* field[8] = data_dig */
  6,   /* field[6] = data_msg */
  9,   /* field[9] = data_req */
  10,   /* field[10] = data_update */
  11,   /* field[11] = empty */
  7,   /* field[7] = hello */
  18,   /* field[18] = leadership_msg */
  4,   /* field[4] = mem_req */
  5,   /* field[5] = mem_res */
  0,   /* field[0] = nonce */
  19,   /* field[19] = peer_identity */
  21,   /* field[21] = privateReq */
  22,   /* field[22] = privateRes */
  23,   /* field[23] = private_data */
  13,   /* field[13] = state_info */
  15,   /* field[15] = state_info_pull_req */
  16,   /* field[16] = state_request */
  17,   /* field[17] = state_response */
  14,   /* field[14] = state_snapshot */
  2,   /* field[2] = tag */
};
static const ProtobufCIntRange gossip__gossip_message__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 5, 3 },
  { 0, 24 }
};
const ProtobufCMessageDescriptor gossip__gossip_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.GossipMessage",
  "GossipMessage",
  "Gossip__GossipMessage",
  "gossip",
  sizeof(Gossip__GossipMessage),
  24,
  gossip__gossip_message__field_descriptors,
  gossip__gossip_message__field_indices_by_name,
  2,  gossip__gossip_message__number_ranges,
  (ProtobufCMessageInit) gossip__gossip_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__state_info__field_descriptors[4] =
{
  {
    "timestamp",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__StateInfo, timestamp),
    &gossip__peer_time__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "pki_id",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__StateInfo, has_pki_id),
    offsetof(Gossip__StateInfo, pki_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_MAC",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__StateInfo, has_channel_mac),
    offsetof(Gossip__StateInfo, channel_mac),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "properties",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__StateInfo, properties),
    &gossip__properties__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__state_info__field_indices_by_name[] = {
  2,   /* field[2] = channel_MAC */
  1,   /* field[1] = pki_id */
  3,   /* field[3] = properties */
  0,   /* field[0] = timestamp */
};
static const ProtobufCIntRange gossip__state_info__number_ranges[1 + 1] =
{
  { 2, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor gossip__state_info__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.StateInfo",
  "StateInfo",
  "Gossip__StateInfo",
  "gossip",
  sizeof(Gossip__StateInfo),
  4,
  gossip__state_info__field_descriptors,
  gossip__state_info__field_indices_by_name,
  1,  gossip__state_info__number_ranges,
  (ProtobufCMessageInit) gossip__state_info__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__properties__field_descriptors[3] =
{
  {
    "ledger_height",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__Properties, has_ledger_height),
    offsetof(Gossip__Properties, ledger_height),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "left_channel",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Gossip__Properties, has_left_channel),
    offsetof(Gossip__Properties, left_channel),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "chaincodes",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__Properties, n_chaincodes),
    offsetof(Gossip__Properties, chaincodes),
    &gossip__chaincode__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__properties__field_indices_by_name[] = {
  2,   /* field[2] = chaincodes */
  0,   /* field[0] = ledger_height */
  1,   /* field[1] = left_channel */
};
static const ProtobufCIntRange gossip__properties__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__properties__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Properties",
  "Properties",
  "Gossip__Properties",
  "gossip",
  sizeof(Gossip__Properties),
  3,
  gossip__properties__field_descriptors,
  gossip__properties__field_indices_by_name,
  1,  gossip__properties__number_ranges,
  (ProtobufCMessageInit) gossip__properties__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__state_info_snapshot__field_descriptors[1] =
{
  {
    "elements",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__StateInfoSnapshot, n_elements),
    offsetof(Gossip__StateInfoSnapshot, elements),
    &gossip__envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__state_info_snapshot__field_indices_by_name[] = {
  0,   /* field[0] = elements */
};
static const ProtobufCIntRange gossip__state_info_snapshot__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__state_info_snapshot__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.StateInfoSnapshot",
  "StateInfoSnapshot",
  "Gossip__StateInfoSnapshot",
  "gossip",
  sizeof(Gossip__StateInfoSnapshot),
  1,
  gossip__state_info_snapshot__field_descriptors,
  gossip__state_info_snapshot__field_indices_by_name,
  1,  gossip__state_info_snapshot__number_ranges,
  (ProtobufCMessageInit) gossip__state_info_snapshot__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__state_info_pull_request__field_descriptors[1] =
{
  {
    "channel_MAC",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__StateInfoPullRequest, has_channel_mac),
    offsetof(Gossip__StateInfoPullRequest, channel_mac),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__state_info_pull_request__field_indices_by_name[] = {
  0,   /* field[0] = channel_MAC */
};
static const ProtobufCIntRange gossip__state_info_pull_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__state_info_pull_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.StateInfoPullRequest",
  "StateInfoPullRequest",
  "Gossip__StateInfoPullRequest",
  "gossip",
  sizeof(Gossip__StateInfoPullRequest),
  1,
  gossip__state_info_pull_request__field_descriptors,
  gossip__state_info_pull_request__field_indices_by_name,
  1,  gossip__state_info_pull_request__number_ranges,
  (ProtobufCMessageInit) gossip__state_info_pull_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__conn_establish__field_descriptors[3] =
{
  {
    "pki_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__ConnEstablish, has_pki_id),
    offsetof(Gossip__ConnEstablish, pki_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "identity",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__ConnEstablish, has_identity),
    offsetof(Gossip__ConnEstablish, identity),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tls_cert_hash",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__ConnEstablish, has_tls_cert_hash),
    offsetof(Gossip__ConnEstablish, tls_cert_hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__conn_establish__field_indices_by_name[] = {
  1,   /* field[1] = identity */
  0,   /* field[0] = pki_id */
  2,   /* field[2] = tls_cert_hash */
};
static const ProtobufCIntRange gossip__conn_establish__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__conn_establish__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.ConnEstablish",
  "ConnEstablish",
  "Gossip__ConnEstablish",
  "gossip",
  sizeof(Gossip__ConnEstablish),
  3,
  gossip__conn_establish__field_descriptors,
  gossip__conn_establish__field_indices_by_name,
  1,  gossip__conn_establish__number_ranges,
  (ProtobufCMessageInit) gossip__conn_establish__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__peer_identity__field_descriptors[3] =
{
  {
    "pki_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PeerIdentity, has_pki_id),
    offsetof(Gossip__PeerIdentity, pki_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cert",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PeerIdentity, has_cert),
    offsetof(Gossip__PeerIdentity, cert),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "metadata",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PeerIdentity, has_metadata),
    offsetof(Gossip__PeerIdentity, metadata),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__peer_identity__field_indices_by_name[] = {
  1,   /* field[1] = cert */
  2,   /* field[2] = metadata */
  0,   /* field[0] = pki_id */
};
static const ProtobufCIntRange gossip__peer_identity__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__peer_identity__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PeerIdentity",
  "PeerIdentity",
  "Gossip__PeerIdentity",
  "gossip",
  sizeof(Gossip__PeerIdentity),
  3,
  gossip__peer_identity__field_descriptors,
  gossip__peer_identity__field_indices_by_name,
  1,  gossip__peer_identity__number_ranges,
  (ProtobufCMessageInit) gossip__peer_identity__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__data_request__field_descriptors[3] =
{
  {
    "nonce",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__DataRequest, has_nonce),
    offsetof(Gossip__DataRequest, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "digests",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__DataRequest, n_digests),
    offsetof(Gossip__DataRequest, digests),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Gossip__DataRequest, has_msg_type),
    offsetof(Gossip__DataRequest, msg_type),
    &gossip__pull_msg_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__data_request__field_indices_by_name[] = {
  1,   /* field[1] = digests */
  2,   /* field[2] = msg_type */
  0,   /* field[0] = nonce */
};
static const ProtobufCIntRange gossip__data_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__data_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.DataRequest",
  "DataRequest",
  "Gossip__DataRequest",
  "gossip",
  sizeof(Gossip__DataRequest),
  3,
  gossip__data_request__field_descriptors,
  gossip__data_request__field_indices_by_name,
  1,  gossip__data_request__number_ranges,
  (ProtobufCMessageInit) gossip__data_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__gossip_hello__field_descriptors[3] =
{
  {
    "nonce",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__GossipHello, has_nonce),
    offsetof(Gossip__GossipHello, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "metadata",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__GossipHello, has_metadata),
    offsetof(Gossip__GossipHello, metadata),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Gossip__GossipHello, has_msg_type),
    offsetof(Gossip__GossipHello, msg_type),
    &gossip__pull_msg_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__gossip_hello__field_indices_by_name[] = {
  1,   /* field[1] = metadata */
  2,   /* field[2] = msg_type */
  0,   /* field[0] = nonce */
};
static const ProtobufCIntRange gossip__gossip_hello__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__gossip_hello__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.GossipHello",
  "GossipHello",
  "Gossip__GossipHello",
  "gossip",
  sizeof(Gossip__GossipHello),
  3,
  gossip__gossip_hello__field_descriptors,
  gossip__gossip_hello__field_indices_by_name,
  1,  gossip__gossip_hello__number_ranges,
  (ProtobufCMessageInit) gossip__gossip_hello__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__data_update__field_descriptors[3] =
{
  {
    "nonce",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__DataUpdate, has_nonce),
    offsetof(Gossip__DataUpdate, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__DataUpdate, n_data),
    offsetof(Gossip__DataUpdate, data),
    &gossip__envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Gossip__DataUpdate, has_msg_type),
    offsetof(Gossip__DataUpdate, msg_type),
    &gossip__pull_msg_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__data_update__field_indices_by_name[] = {
  1,   /* field[1] = data */
  2,   /* field[2] = msg_type */
  0,   /* field[0] = nonce */
};
static const ProtobufCIntRange gossip__data_update__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__data_update__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.DataUpdate",
  "DataUpdate",
  "Gossip__DataUpdate",
  "gossip",
  sizeof(Gossip__DataUpdate),
  3,
  gossip__data_update__field_descriptors,
  gossip__data_update__field_indices_by_name,
  1,  gossip__data_update__number_ranges,
  (ProtobufCMessageInit) gossip__data_update__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__data_digest__field_descriptors[3] =
{
  {
    "nonce",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__DataDigest, has_nonce),
    offsetof(Gossip__DataDigest, nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "digests",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__DataDigest, n_digests),
    offsetof(Gossip__DataDigest, digests),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg_type",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Gossip__DataDigest, has_msg_type),
    offsetof(Gossip__DataDigest, msg_type),
    &gossip__pull_msg_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__data_digest__field_indices_by_name[] = {
  1,   /* field[1] = digests */
  2,   /* field[2] = msg_type */
  0,   /* field[0] = nonce */
};
static const ProtobufCIntRange gossip__data_digest__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__data_digest__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.DataDigest",
  "DataDigest",
  "Gossip__DataDigest",
  "gossip",
  sizeof(Gossip__DataDigest),
  3,
  gossip__data_digest__field_descriptors,
  gossip__data_digest__field_indices_by_name,
  1,  gossip__data_digest__number_ranges,
  (ProtobufCMessageInit) gossip__data_digest__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__data_message__field_descriptors[1] =
{
  {
    "payload",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__DataMessage, payload),
    &gossip__payload__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__data_message__field_indices_by_name[] = {
  0,   /* field[0] = payload */
};
static const ProtobufCIntRange gossip__data_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__data_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.DataMessage",
  "DataMessage",
  "Gossip__DataMessage",
  "gossip",
  sizeof(Gossip__DataMessage),
  1,
  gossip__data_message__field_descriptors,
  gossip__data_message__field_indices_by_name,
  1,  gossip__data_message__number_ranges,
  (ProtobufCMessageInit) gossip__data_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__private_data_message__field_descriptors[1] =
{
  {
    "payload",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__PrivateDataMessage, payload),
    &gossip__private_payload__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__private_data_message__field_indices_by_name[] = {
  0,   /* field[0] = payload */
};
static const ProtobufCIntRange gossip__private_data_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__private_data_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PrivateDataMessage",
  "PrivateDataMessage",
  "Gossip__PrivateDataMessage",
  "gossip",
  sizeof(Gossip__PrivateDataMessage),
  1,
  gossip__private_data_message__field_descriptors,
  gossip__private_data_message__field_indices_by_name,
  1,  gossip__private_data_message__number_ranges,
  (ProtobufCMessageInit) gossip__private_data_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__payload__field_descriptors[3] =
{
  {
    "seq_num",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__Payload, has_seq_num),
    offsetof(Gossip__Payload, seq_num),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Payload, has_data),
    offsetof(Gossip__Payload, data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "private_data",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Payload, n_private_data),
    offsetof(Gossip__Payload, private_data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__payload__field_indices_by_name[] = {
  1,   /* field[1] = data */
  2,   /* field[2] = private_data */
  0,   /* field[0] = seq_num */
};
static const ProtobufCIntRange gossip__payload__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__payload__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Payload",
  "Payload",
  "Gossip__Payload",
  "gossip",
  sizeof(Gossip__Payload),
  3,
  gossip__payload__field_descriptors,
  gossip__payload__field_indices_by_name,
  1,  gossip__payload__number_ranges,
  (ProtobufCMessageInit) gossip__payload__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__private_payload__field_descriptors[6] =
{
  {
    "collection_name",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PrivatePayload, collection_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "namespace",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PrivatePayload, namespace_),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tx_id",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PrivatePayload, tx_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "private_rwset",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PrivatePayload, has_private_rwset),
    offsetof(Gossip__PrivatePayload, private_rwset),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "private_sim_height",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PrivatePayload, has_private_sim_height),
    offsetof(Gossip__PrivatePayload, private_sim_height),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "collection_configs",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__PrivatePayload, collection_configs),
    &common__collection_config_package__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__private_payload__field_indices_by_name[] = {
  5,   /* field[5] = collection_configs */
  0,   /* field[0] = collection_name */
  1,   /* field[1] = namespace */
  3,   /* field[3] = private_rwset */
  4,   /* field[4] = private_sim_height */
  2,   /* field[2] = tx_id */
};
static const ProtobufCIntRange gossip__private_payload__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor gossip__private_payload__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PrivatePayload",
  "PrivatePayload",
  "Gossip__PrivatePayload",
  "gossip",
  sizeof(Gossip__PrivatePayload),
  6,
  gossip__private_payload__field_descriptors,
  gossip__private_payload__field_indices_by_name,
  1,  gossip__private_payload__number_ranges,
  (ProtobufCMessageInit) gossip__private_payload__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__alive_message__field_descriptors[3] =
{
  {
    "membership",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__AliveMessage, membership),
    &gossip__member__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "timestamp",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__AliveMessage, timestamp),
    &gossip__peer_time__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "identity",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__AliveMessage, has_identity),
    offsetof(Gossip__AliveMessage, identity),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__alive_message__field_indices_by_name[] = {
  2,   /* field[2] = identity */
  0,   /* field[0] = membership */
  1,   /* field[1] = timestamp */
};
static const ProtobufCIntRange gossip__alive_message__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 4, 2 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__alive_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.AliveMessage",
  "AliveMessage",
  "Gossip__AliveMessage",
  "gossip",
  sizeof(Gossip__AliveMessage),
  3,
  gossip__alive_message__field_descriptors,
  gossip__alive_message__field_indices_by_name,
  2,  gossip__alive_message__number_ranges,
  (ProtobufCMessageInit) gossip__alive_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__leadership_message__field_descriptors[3] =
{
  {
    "pki_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__LeadershipMessage, has_pki_id),
    offsetof(Gossip__LeadershipMessage, pki_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "timestamp",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__LeadershipMessage, timestamp),
    &gossip__peer_time__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "is_declaration",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Gossip__LeadershipMessage, has_is_declaration),
    offsetof(Gossip__LeadershipMessage, is_declaration),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__leadership_message__field_indices_by_name[] = {
  2,   /* field[2] = is_declaration */
  0,   /* field[0] = pki_id */
  1,   /* field[1] = timestamp */
};
static const ProtobufCIntRange gossip__leadership_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__leadership_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.LeadershipMessage",
  "LeadershipMessage",
  "Gossip__LeadershipMessage",
  "gossip",
  sizeof(Gossip__LeadershipMessage),
  3,
  gossip__leadership_message__field_descriptors,
  gossip__leadership_message__field_indices_by_name,
  1,  gossip__leadership_message__number_ranges,
  (ProtobufCMessageInit) gossip__leadership_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__peer_time__field_descriptors[2] =
{
  {
    "inc_num",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PeerTime, has_inc_num),
    offsetof(Gossip__PeerTime, inc_num),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "seq_num",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PeerTime, has_seq_num),
    offsetof(Gossip__PeerTime, seq_num),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__peer_time__field_indices_by_name[] = {
  0,   /* field[0] = inc_num */
  1,   /* field[1] = seq_num */
};
static const ProtobufCIntRange gossip__peer_time__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__peer_time__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PeerTime",
  "PeerTime",
  "Gossip__PeerTime",
  "gossip",
  sizeof(Gossip__PeerTime),
  2,
  gossip__peer_time__field_descriptors,
  gossip__peer_time__field_indices_by_name,
  1,  gossip__peer_time__number_ranges,
  (ProtobufCMessageInit) gossip__peer_time__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__membership_request__field_descriptors[2] =
{
  {
    "self_information",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__MembershipRequest, self_information),
    &gossip__envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "known",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__MembershipRequest, n_known),
    offsetof(Gossip__MembershipRequest, known),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__membership_request__field_indices_by_name[] = {
  1,   /* field[1] = known */
  0,   /* field[0] = self_information */
};
static const ProtobufCIntRange gossip__membership_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__membership_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.MembershipRequest",
  "MembershipRequest",
  "Gossip__MembershipRequest",
  "gossip",
  sizeof(Gossip__MembershipRequest),
  2,
  gossip__membership_request__field_descriptors,
  gossip__membership_request__field_indices_by_name,
  1,  gossip__membership_request__number_ranges,
  (ProtobufCMessageInit) gossip__membership_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__membership_response__field_descriptors[2] =
{
  {
    "alive",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__MembershipResponse, n_alive),
    offsetof(Gossip__MembershipResponse, alive),
    &gossip__envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dead",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__MembershipResponse, n_dead),
    offsetof(Gossip__MembershipResponse, dead),
    &gossip__envelope__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__membership_response__field_indices_by_name[] = {
  0,   /* field[0] = alive */
  1,   /* field[1] = dead */
};
static const ProtobufCIntRange gossip__membership_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__membership_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.MembershipResponse",
  "MembershipResponse",
  "Gossip__MembershipResponse",
  "gossip",
  sizeof(Gossip__MembershipResponse),
  2,
  gossip__membership_response__field_descriptors,
  gossip__membership_response__field_indices_by_name,
  1,  gossip__membership_response__number_ranges,
  (ProtobufCMessageInit) gossip__membership_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__member__field_descriptors[3] =
{
  {
    "endpoint",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__Member, endpoint),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "metadata",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Member, has_metadata),
    offsetof(Gossip__Member, metadata),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "pki_id",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Member, has_pki_id),
    offsetof(Gossip__Member, pki_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__member__field_indices_by_name[] = {
  0,   /* field[0] = endpoint */
  1,   /* field[1] = metadata */
  2,   /* field[2] = pki_id */
};
static const ProtobufCIntRange gossip__member__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__member__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Member",
  "Member",
  "Gossip__Member",
  "gossip",
  sizeof(Gossip__Member),
  3,
  gossip__member__field_descriptors,
  gossip__member__field_indices_by_name,
  1,  gossip__member__number_ranges,
  (ProtobufCMessageInit) gossip__member__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define gossip__empty__field_descriptors NULL
#define gossip__empty__field_indices_by_name NULL
#define gossip__empty__number_ranges NULL
const ProtobufCMessageDescriptor gossip__empty__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Empty",
  "Empty",
  "Gossip__Empty",
  "gossip",
  sizeof(Gossip__Empty),
  0,
  gossip__empty__field_descriptors,
  gossip__empty__field_indices_by_name,
  0,  gossip__empty__number_ranges,
  (ProtobufCMessageInit) gossip__empty__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__remote_state_request__field_descriptors[2] =
{
  {
    "start_seq_num",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__RemoteStateRequest, has_start_seq_num),
    offsetof(Gossip__RemoteStateRequest, start_seq_num),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "end_seq_num",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__RemoteStateRequest, has_end_seq_num),
    offsetof(Gossip__RemoteStateRequest, end_seq_num),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__remote_state_request__field_indices_by_name[] = {
  1,   /* field[1] = end_seq_num */
  0,   /* field[0] = start_seq_num */
};
static const ProtobufCIntRange gossip__remote_state_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__remote_state_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.RemoteStateRequest",
  "RemoteStateRequest",
  "Gossip__RemoteStateRequest",
  "gossip",
  sizeof(Gossip__RemoteStateRequest),
  2,
  gossip__remote_state_request__field_descriptors,
  gossip__remote_state_request__field_indices_by_name,
  1,  gossip__remote_state_request__number_ranges,
  (ProtobufCMessageInit) gossip__remote_state_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__remote_state_response__field_descriptors[1] =
{
  {
    "payloads",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__RemoteStateResponse, n_payloads),
    offsetof(Gossip__RemoteStateResponse, payloads),
    &gossip__payload__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__remote_state_response__field_indices_by_name[] = {
  0,   /* field[0] = payloads */
};
static const ProtobufCIntRange gossip__remote_state_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__remote_state_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.RemoteStateResponse",
  "RemoteStateResponse",
  "Gossip__RemoteStateResponse",
  "gossip",
  sizeof(Gossip__RemoteStateResponse),
  1,
  gossip__remote_state_response__field_descriptors,
  gossip__remote_state_response__field_indices_by_name,
  1,  gossip__remote_state_response__number_ranges,
  (ProtobufCMessageInit) gossip__remote_state_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__remote_pvt_data_request__field_descriptors[1] =
{
  {
    "digests",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__RemotePvtDataRequest, n_digests),
    offsetof(Gossip__RemotePvtDataRequest, digests),
    &gossip__pvt_data_digest__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__remote_pvt_data_request__field_indices_by_name[] = {
  0,   /* field[0] = digests */
};
static const ProtobufCIntRange gossip__remote_pvt_data_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__remote_pvt_data_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.RemotePvtDataRequest",
  "RemotePvtDataRequest",
  "Gossip__RemotePvtDataRequest",
  "gossip",
  sizeof(Gossip__RemotePvtDataRequest),
  1,
  gossip__remote_pvt_data_request__field_descriptors,
  gossip__remote_pvt_data_request__field_indices_by_name,
  1,  gossip__remote_pvt_data_request__number_ranges,
  (ProtobufCMessageInit) gossip__remote_pvt_data_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__pvt_data_digest__field_descriptors[5] =
{
  {
    "tx_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PvtDataDigest, tx_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "namespace",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PvtDataDigest, namespace_),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "collection",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__PvtDataDigest, collection),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "block_seq",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PvtDataDigest, has_block_seq),
    offsetof(Gossip__PvtDataDigest, block_seq),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "seq_in_block",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PvtDataDigest, has_seq_in_block),
    offsetof(Gossip__PvtDataDigest, seq_in_block),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__pvt_data_digest__field_indices_by_name[] = {
  3,   /* field[3] = block_seq */
  2,   /* field[2] = collection */
  1,   /* field[1] = namespace */
  4,   /* field[4] = seq_in_block */
  0,   /* field[0] = tx_id */
};
static const ProtobufCIntRange gossip__pvt_data_digest__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor gossip__pvt_data_digest__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PvtDataDigest",
  "PvtDataDigest",
  "Gossip__PvtDataDigest",
  "gossip",
  sizeof(Gossip__PvtDataDigest),
  5,
  gossip__pvt_data_digest__field_descriptors,
  gossip__pvt_data_digest__field_indices_by_name,
  1,  gossip__pvt_data_digest__number_ranges,
  (ProtobufCMessageInit) gossip__pvt_data_digest__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__remote_pvt_data_response__field_descriptors[1] =
{
  {
    "elements",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Gossip__RemotePvtDataResponse, n_elements),
    offsetof(Gossip__RemotePvtDataResponse, elements),
    &gossip__pvt_data_element__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__remote_pvt_data_response__field_indices_by_name[] = {
  0,   /* field[0] = elements */
};
static const ProtobufCIntRange gossip__remote_pvt_data_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__remote_pvt_data_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.RemotePvtDataResponse",
  "RemotePvtDataResponse",
  "Gossip__RemotePvtDataResponse",
  "gossip",
  sizeof(Gossip__RemotePvtDataResponse),
  1,
  gossip__remote_pvt_data_response__field_descriptors,
  gossip__remote_pvt_data_response__field_indices_by_name,
  1,  gossip__remote_pvt_data_response__number_ranges,
  (ProtobufCMessageInit) gossip__remote_pvt_data_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__pvt_data_element__field_descriptors[2] =
{
  {
    "digest",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Gossip__PvtDataElement, digest),
    &gossip__pvt_data_digest__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "payload",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PvtDataElement, n_payload),
    offsetof(Gossip__PvtDataElement, payload),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__pvt_data_element__field_indices_by_name[] = {
  0,   /* field[0] = digest */
  1,   /* field[1] = payload */
};
static const ProtobufCIntRange gossip__pvt_data_element__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__pvt_data_element__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PvtDataElement",
  "PvtDataElement",
  "Gossip__PvtDataElement",
  "gossip",
  sizeof(Gossip__PvtDataElement),
  2,
  gossip__pvt_data_element__field_descriptors,
  gossip__pvt_data_element__field_indices_by_name,
  1,  gossip__pvt_data_element__number_ranges,
  (ProtobufCMessageInit) gossip__pvt_data_element__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__pvt_data_payload__field_descriptors[2] =
{
  {
    "tx_seq_in_block",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Gossip__PvtDataPayload, has_tx_seq_in_block),
    offsetof(Gossip__PvtDataPayload, tx_seq_in_block),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "payload",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__PvtDataPayload, has_payload),
    offsetof(Gossip__PvtDataPayload, payload),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__pvt_data_payload__field_indices_by_name[] = {
  1,   /* field[1] = payload */
  0,   /* field[0] = tx_seq_in_block */
};
static const ProtobufCIntRange gossip__pvt_data_payload__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor gossip__pvt_data_payload__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.PvtDataPayload",
  "PvtDataPayload",
  "Gossip__PvtDataPayload",
  "gossip",
  sizeof(Gossip__PvtDataPayload),
  2,
  gossip__pvt_data_payload__field_descriptors,
  gossip__pvt_data_payload__field_indices_by_name,
  1,  gossip__pvt_data_payload__number_ranges,
  (ProtobufCMessageInit) gossip__pvt_data_payload__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__acknowledgement__field_descriptors[1] =
{
  {
    "error",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__Acknowledgement, error),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__acknowledgement__field_indices_by_name[] = {
  0,   /* field[0] = error */
};
static const ProtobufCIntRange gossip__acknowledgement__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor gossip__acknowledgement__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Acknowledgement",
  "Acknowledgement",
  "Gossip__Acknowledgement",
  "gossip",
  sizeof(Gossip__Acknowledgement),
  1,
  gossip__acknowledgement__field_descriptors,
  gossip__acknowledgement__field_indices_by_name,
  1,  gossip__acknowledgement__number_ranges,
  (ProtobufCMessageInit) gossip__acknowledgement__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor gossip__chaincode__field_descriptors[3] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__Chaincode, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Gossip__Chaincode, version),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "metadata",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Gossip__Chaincode, has_metadata),
    offsetof(Gossip__Chaincode, metadata),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned gossip__chaincode__field_indices_by_name[] = {
  2,   /* field[2] = metadata */
  0,   /* field[0] = name */
  1,   /* field[1] = version */
};
static const ProtobufCIntRange gossip__chaincode__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor gossip__chaincode__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "gossip.Chaincode",
  "Chaincode",
  "Gossip__Chaincode",
  "gossip",
  sizeof(Gossip__Chaincode),
  3,
  gossip__chaincode__field_descriptors,
  gossip__chaincode__field_indices_by_name,
  1,  gossip__chaincode__number_ranges,
  (ProtobufCMessageInit) gossip__chaincode__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue gossip__pull_msg_type__enum_values_by_number[3] =
{
  { "UNDEFINED", "GOSSIP__PULL_MSG_TYPE__UNDEFINED", 0 },
  { "BLOCK_MSG", "GOSSIP__PULL_MSG_TYPE__BLOCK_MSG", 1 },
  { "IDENTITY_MSG", "GOSSIP__PULL_MSG_TYPE__IDENTITY_MSG", 2 },
};
static const ProtobufCIntRange gossip__pull_msg_type__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex gossip__pull_msg_type__enum_values_by_name[3] =
{
  { "BLOCK_MSG", 1 },
  { "IDENTITY_MSG", 2 },
  { "UNDEFINED", 0 },
};
const ProtobufCEnumDescriptor gossip__pull_msg_type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "gossip.PullMsgType",
  "PullMsgType",
  "Gossip__PullMsgType",
  "gossip",
  3,
  gossip__pull_msg_type__enum_values_by_number,
  3,
  gossip__pull_msg_type__enum_values_by_name,
  1,
  gossip__pull_msg_type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCMethodDescriptor gossip__gossip__method_descriptors[2] =
{
  { "GossipStream", &gossip__envelope__descriptor, &gossip__envelope__descriptor },
  { "Ping", &gossip__empty__descriptor, &gossip__empty__descriptor },
};
const unsigned gossip__gossip__method_indices_by_name[] = {
  0,        /* GossipStream */
  1         /* Ping */
};
const ProtobufCServiceDescriptor gossip__gossip__descriptor =
{
  PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC,
  "gossip.Gossip",
  "Gossip",
  "Gossip__Gossip",
  "gossip",
  2,
  gossip__gossip__method_descriptors,
  gossip__gossip__method_indices_by_name
};
void gossip__gossip__gossip_stream(ProtobufCService *service,
                                   const Gossip__Envelope *input,
                                   Gossip__Envelope_Closure closure,
                                   void *closure_data)
{
  assert(service->descriptor == &gossip__gossip__descriptor);
  service->invoke(service, 0, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
}
void gossip__gossip__ping(ProtobufCService *service,
                          const Gossip__Empty *input,
                          Gossip__Empty_Closure closure,
                          void *closure_data)
{
  assert(service->descriptor == &gossip__gossip__descriptor);
  service->invoke(service, 1, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
}
void gossip__gossip__init (Gossip__Gossip_Service *service,
                           Gossip__Gossip_ServiceDestroy destroy)
{
  protobuf_c_service_generated_init (&service->base,
                                     &gossip__gossip__descriptor,
                                     (ProtobufCServiceDestroy) destroy);
}
