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

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

#include "Mumble.pb-c.h"
void   mumble_proto__version__init
                     (MumbleProto__Version         *message)
{
  static const MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
  *message = init_value;
}
size_t mumble_proto__version__get_packed_size
                     (const MumbleProto__Version *message)
{
  assert(message->base.descriptor == &mumble_proto__version__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__version__pack
                     (const MumbleProto__Version *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__version__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__version__pack_to_buffer
                     (const MumbleProto__Version *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__version__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__Version *
       mumble_proto__version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__Version *)
     protobuf_c_message_unpack (&mumble_proto__version__descriptor,
                                allocator, len, data);
}
void   mumble_proto__version__free_unpacked
                     (MumbleProto__Version *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__version__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__udptunnel__init
                     (MumbleProto__UDPTunnel         *message)
{
  static const MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
  *message = init_value;
}
size_t mumble_proto__udptunnel__get_packed_size
                     (const MumbleProto__UDPTunnel *message)
{
  assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__udptunnel__pack
                     (const MumbleProto__UDPTunnel *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__udptunnel__pack_to_buffer
                     (const MumbleProto__UDPTunnel *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__UDPTunnel *
       mumble_proto__udptunnel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__UDPTunnel *)
     protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
                                allocator, len, data);
}
void   mumble_proto__udptunnel__free_unpacked
                     (MumbleProto__UDPTunnel *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__authenticate__init
                     (MumbleProto__Authenticate         *message)
{
  static const MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
  *message = init_value;
}
size_t mumble_proto__authenticate__get_packed_size
                     (const MumbleProto__Authenticate *message)
{
  assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__authenticate__pack
                     (const MumbleProto__Authenticate *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__authenticate__pack_to_buffer
                     (const MumbleProto__Authenticate *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__Authenticate *
       mumble_proto__authenticate__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__Authenticate *)
     protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
                                allocator, len, data);
}
void   mumble_proto__authenticate__free_unpacked
                     (MumbleProto__Authenticate *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__ping__init
                     (MumbleProto__Ping         *message)
{
  static const MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
  *message = init_value;
}
size_t mumble_proto__ping__get_packed_size
                     (const MumbleProto__Ping *message)
{
  assert(message->base.descriptor == &mumble_proto__ping__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__ping__pack
                     (const MumbleProto__Ping *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__ping__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__ping__pack_to_buffer
                     (const MumbleProto__Ping *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__ping__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__Ping *
       mumble_proto__ping__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__Ping *)
     protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
                                allocator, len, data);
}
void   mumble_proto__ping__free_unpacked
                     (MumbleProto__Ping *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__ping__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__reject__init
                     (MumbleProto__Reject         *message)
{
  static const MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
  *message = init_value;
}
size_t mumble_proto__reject__get_packed_size
                     (const MumbleProto__Reject *message)
{
  assert(message->base.descriptor == &mumble_proto__reject__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__reject__pack
                     (const MumbleProto__Reject *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__reject__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__reject__pack_to_buffer
                     (const MumbleProto__Reject *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__reject__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__Reject *
       mumble_proto__reject__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__Reject *)
     protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
                                allocator, len, data);
}
void   mumble_proto__reject__free_unpacked
                     (MumbleProto__Reject *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__reject__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__server_config__init
                     (MumbleProto__ServerConfig         *message)
{
  static const MumbleProto__ServerConfig init_value = MUMBLE_PROTO__SERVER_CONFIG__INIT;
  *message = init_value;
}
size_t mumble_proto__server_config__get_packed_size
                     (const MumbleProto__ServerConfig *message)
{
  assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__server_config__pack
                     (const MumbleProto__ServerConfig *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__server_config__pack_to_buffer
                     (const MumbleProto__ServerConfig *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ServerConfig *
       mumble_proto__server_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ServerConfig *)
     protobuf_c_message_unpack (&mumble_proto__server_config__descriptor,
                                allocator, len, data);
}
void   mumble_proto__server_config__free_unpacked
                     (MumbleProto__ServerConfig *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__server_sync__init
                     (MumbleProto__ServerSync         *message)
{
  static const MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
  *message = init_value;
}
size_t mumble_proto__server_sync__get_packed_size
                     (const MumbleProto__ServerSync *message)
{
  assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__server_sync__pack
                     (const MumbleProto__ServerSync *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__server_sync__pack_to_buffer
                     (const MumbleProto__ServerSync *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ServerSync *
       mumble_proto__server_sync__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ServerSync *)
     protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
                                allocator, len, data);
}
void   mumble_proto__server_sync__free_unpacked
                     (MumbleProto__ServerSync *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__channel_remove__init
                     (MumbleProto__ChannelRemove         *message)
{
  static const MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
  *message = init_value;
}
size_t mumble_proto__channel_remove__get_packed_size
                     (const MumbleProto__ChannelRemove *message)
{
  assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__channel_remove__pack
                     (const MumbleProto__ChannelRemove *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__channel_remove__pack_to_buffer
                     (const MumbleProto__ChannelRemove *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ChannelRemove *
       mumble_proto__channel_remove__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ChannelRemove *)
     protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
                                allocator, len, data);
}
void   mumble_proto__channel_remove__free_unpacked
                     (MumbleProto__ChannelRemove *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__channel_state__init
                     (MumbleProto__ChannelState         *message)
{
  static const MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
  *message = init_value;
}
size_t mumble_proto__channel_state__get_packed_size
                     (const MumbleProto__ChannelState *message)
{
  assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__channel_state__pack
                     (const MumbleProto__ChannelState *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__channel_state__pack_to_buffer
                     (const MumbleProto__ChannelState *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ChannelState *
       mumble_proto__channel_state__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ChannelState *)
     protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
                                allocator, len, data);
}
void   mumble_proto__channel_state__free_unpacked
                     (MumbleProto__ChannelState *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__user_remove__init
                     (MumbleProto__UserRemove         *message)
{
  static const MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
  *message = init_value;
}
size_t mumble_proto__user_remove__get_packed_size
                     (const MumbleProto__UserRemove *message)
{
  assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__user_remove__pack
                     (const MumbleProto__UserRemove *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__user_remove__pack_to_buffer
                     (const MumbleProto__UserRemove *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__UserRemove *
       mumble_proto__user_remove__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__UserRemove *)
     protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
                                allocator, len, data);
}
void   mumble_proto__user_remove__free_unpacked
                     (MumbleProto__UserRemove *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__user_state__init
                     (MumbleProto__UserState         *message)
{
  static const MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
  *message = init_value;
}
size_t mumble_proto__user_state__get_packed_size
                     (const MumbleProto__UserState *message)
{
  assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__user_state__pack
                     (const MumbleProto__UserState *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__user_state__pack_to_buffer
                     (const MumbleProto__UserState *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__UserState *
       mumble_proto__user_state__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__UserState *)
     protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
                                allocator, len, data);
}
void   mumble_proto__user_state__free_unpacked
                     (MumbleProto__UserState *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__ban_list__ban_entry__init
                     (MumbleProto__BanList__BanEntry         *message)
{
  static const MumbleProto__BanList__BanEntry init_value = MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT;
  *message = init_value;
}
void   mumble_proto__ban_list__init
                     (MumbleProto__BanList         *message)
{
  static const MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
  *message = init_value;
}
size_t mumble_proto__ban_list__get_packed_size
                     (const MumbleProto__BanList *message)
{
  assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__ban_list__pack
                     (const MumbleProto__BanList *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__ban_list__pack_to_buffer
                     (const MumbleProto__BanList *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__BanList *
       mumble_proto__ban_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__BanList *)
     protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
                                allocator, len, data);
}
void   mumble_proto__ban_list__free_unpacked
                     (MumbleProto__BanList *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__text_message__init
                     (MumbleProto__TextMessage         *message)
{
  static const MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
  *message = init_value;
}
size_t mumble_proto__text_message__get_packed_size
                     (const MumbleProto__TextMessage *message)
{
  assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__text_message__pack
                     (const MumbleProto__TextMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__text_message__pack_to_buffer
                     (const MumbleProto__TextMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__TextMessage *
       mumble_proto__text_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__TextMessage *)
     protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
                                allocator, len, data);
}
void   mumble_proto__text_message__free_unpacked
                     (MumbleProto__TextMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__permission_denied__init
                     (MumbleProto__PermissionDenied         *message)
{
  static const MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
  *message = init_value;
}
size_t mumble_proto__permission_denied__get_packed_size
                     (const MumbleProto__PermissionDenied *message)
{
  assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__permission_denied__pack
                     (const MumbleProto__PermissionDenied *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__permission_denied__pack_to_buffer
                     (const MumbleProto__PermissionDenied *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__PermissionDenied *
       mumble_proto__permission_denied__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__PermissionDenied *)
     protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
                                allocator, len, data);
}
void   mumble_proto__permission_denied__free_unpacked
                     (MumbleProto__PermissionDenied *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__acl__chan_group__init
                     (MumbleProto__ACL__ChanGroup         *message)
{
  static const MumbleProto__ACL__ChanGroup init_value = MUMBLE_PROTO__ACL__CHAN_GROUP__INIT;
  *message = init_value;
}
void   mumble_proto__acl__chan_acl__init
                     (MumbleProto__ACL__ChanACL         *message)
{
  static const MumbleProto__ACL__ChanACL init_value = MUMBLE_PROTO__ACL__CHAN_ACL__INIT;
  *message = init_value;
}
void   mumble_proto__acl__init
                     (MumbleProto__ACL         *message)
{
  static const MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
  *message = init_value;
}
size_t mumble_proto__acl__get_packed_size
                     (const MumbleProto__ACL *message)
{
  assert(message->base.descriptor == &mumble_proto__acl__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__acl__pack
                     (const MumbleProto__ACL *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__acl__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__acl__pack_to_buffer
                     (const MumbleProto__ACL *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__acl__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ACL *
       mumble_proto__acl__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ACL *)
     protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
                                allocator, len, data);
}
void   mumble_proto__acl__free_unpacked
                     (MumbleProto__ACL *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__acl__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__query_users__init
                     (MumbleProto__QueryUsers         *message)
{
  static const MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
  *message = init_value;
}
size_t mumble_proto__query_users__get_packed_size
                     (const MumbleProto__QueryUsers *message)
{
  assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__query_users__pack
                     (const MumbleProto__QueryUsers *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__query_users__pack_to_buffer
                     (const MumbleProto__QueryUsers *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__QueryUsers *
       mumble_proto__query_users__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__QueryUsers *)
     protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
                                allocator, len, data);
}
void   mumble_proto__query_users__free_unpacked
                     (MumbleProto__QueryUsers *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__crypt_setup__init
                     (MumbleProto__CryptSetup         *message)
{
  static const MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
  *message = init_value;
}
size_t mumble_proto__crypt_setup__get_packed_size
                     (const MumbleProto__CryptSetup *message)
{
  assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__crypt_setup__pack
                     (const MumbleProto__CryptSetup *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__crypt_setup__pack_to_buffer
                     (const MumbleProto__CryptSetup *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__CryptSetup *
       mumble_proto__crypt_setup__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__CryptSetup *)
     protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
                                allocator, len, data);
}
void   mumble_proto__crypt_setup__free_unpacked
                     (MumbleProto__CryptSetup *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__context_action_modify__init
                     (MumbleProto__ContextActionModify         *message)
{
  static const MumbleProto__ContextActionModify init_value = MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT;
  *message = init_value;
}
size_t mumble_proto__context_action_modify__get_packed_size
                     (const MumbleProto__ContextActionModify *message)
{
  assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__context_action_modify__pack
                     (const MumbleProto__ContextActionModify *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__context_action_modify__pack_to_buffer
                     (const MumbleProto__ContextActionModify *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ContextActionModify *
       mumble_proto__context_action_modify__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ContextActionModify *)
     protobuf_c_message_unpack (&mumble_proto__context_action_modify__descriptor,
                                allocator, len, data);
}
void   mumble_proto__context_action_modify__free_unpacked
                     (MumbleProto__ContextActionModify *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__context_action__init
                     (MumbleProto__ContextAction         *message)
{
  static const MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
  *message = init_value;
}
size_t mumble_proto__context_action__get_packed_size
                     (const MumbleProto__ContextAction *message)
{
  assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__context_action__pack
                     (const MumbleProto__ContextAction *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__context_action__pack_to_buffer
                     (const MumbleProto__ContextAction *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__ContextAction *
       mumble_proto__context_action__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__ContextAction *)
     protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
                                allocator, len, data);
}
void   mumble_proto__context_action__free_unpacked
                     (MumbleProto__ContextAction *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__user_list__user__init
                     (MumbleProto__UserList__User         *message)
{
  static const MumbleProto__UserList__User init_value = MUMBLE_PROTO__USER_LIST__USER__INIT;
  *message = init_value;
}
void   mumble_proto__user_list__init
                     (MumbleProto__UserList         *message)
{
  static const MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
  *message = init_value;
}
size_t mumble_proto__user_list__get_packed_size
                     (const MumbleProto__UserList *message)
{
  assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__user_list__pack
                     (const MumbleProto__UserList *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__user_list__pack_to_buffer
                     (const MumbleProto__UserList *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__UserList *
       mumble_proto__user_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__UserList *)
     protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
                                allocator, len, data);
}
void   mumble_proto__user_list__free_unpacked
                     (MumbleProto__UserList *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__voice_target__target__init
                     (MumbleProto__VoiceTarget__Target         *message)
{
  static const MumbleProto__VoiceTarget__Target init_value = MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT;
  *message = init_value;
}
void   mumble_proto__voice_target__init
                     (MumbleProto__VoiceTarget         *message)
{
  static const MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
  *message = init_value;
}
size_t mumble_proto__voice_target__get_packed_size
                     (const MumbleProto__VoiceTarget *message)
{
  assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__voice_target__pack
                     (const MumbleProto__VoiceTarget *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__voice_target__pack_to_buffer
                     (const MumbleProto__VoiceTarget *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__VoiceTarget *
       mumble_proto__voice_target__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__VoiceTarget *)
     protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
                                allocator, len, data);
}
void   mumble_proto__voice_target__free_unpacked
                     (MumbleProto__VoiceTarget *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__permission_query__init
                     (MumbleProto__PermissionQuery         *message)
{
  static const MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
  *message = init_value;
}
size_t mumble_proto__permission_query__get_packed_size
                     (const MumbleProto__PermissionQuery *message)
{
  assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__permission_query__pack
                     (const MumbleProto__PermissionQuery *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__permission_query__pack_to_buffer
                     (const MumbleProto__PermissionQuery *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__PermissionQuery *
       mumble_proto__permission_query__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__PermissionQuery *)
     protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
                                allocator, len, data);
}
void   mumble_proto__permission_query__free_unpacked
                     (MumbleProto__PermissionQuery *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__codec_version__init
                     (MumbleProto__CodecVersion         *message)
{
  static const MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
  *message = init_value;
}
size_t mumble_proto__codec_version__get_packed_size
                     (const MumbleProto__CodecVersion *message)
{
  assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__codec_version__pack
                     (const MumbleProto__CodecVersion *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__codec_version__pack_to_buffer
                     (const MumbleProto__CodecVersion *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__CodecVersion *
       mumble_proto__codec_version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__CodecVersion *)
     protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
                                allocator, len, data);
}
void   mumble_proto__codec_version__free_unpacked
                     (MumbleProto__CodecVersion *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__user_stats__stats__init
                     (MumbleProto__UserStats__Stats         *message)
{
  static const MumbleProto__UserStats__Stats init_value = MUMBLE_PROTO__USER_STATS__STATS__INIT;
  *message = init_value;
}
void   mumble_proto__user_stats__init
                     (MumbleProto__UserStats         *message)
{
  static const MumbleProto__UserStats init_value = MUMBLE_PROTO__USER_STATS__INIT;
  *message = init_value;
}
size_t mumble_proto__user_stats__get_packed_size
                     (const MumbleProto__UserStats *message)
{
  assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__user_stats__pack
                     (const MumbleProto__UserStats *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__user_stats__pack_to_buffer
                     (const MumbleProto__UserStats *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__UserStats *
       mumble_proto__user_stats__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__UserStats *)
     protobuf_c_message_unpack (&mumble_proto__user_stats__descriptor,
                                allocator, len, data);
}
void   mumble_proto__user_stats__free_unpacked
                     (MumbleProto__UserStats *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__suggest_config__init
                     (MumbleProto__SuggestConfig         *message)
{
  static const MumbleProto__SuggestConfig init_value = MUMBLE_PROTO__SUGGEST_CONFIG__INIT;
  *message = init_value;
}
size_t mumble_proto__suggest_config__get_packed_size
                     (const MumbleProto__SuggestConfig *message)
{
  assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__suggest_config__pack
                     (const MumbleProto__SuggestConfig *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__suggest_config__pack_to_buffer
                     (const MumbleProto__SuggestConfig *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__SuggestConfig *
       mumble_proto__suggest_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__SuggestConfig *)
     protobuf_c_message_unpack (&mumble_proto__suggest_config__descriptor,
                                allocator, len, data);
}
void   mumble_proto__suggest_config__free_unpacked
                     (MumbleProto__SuggestConfig *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   mumble_proto__request_blob__init
                     (MumbleProto__RequestBlob         *message)
{
  static const MumbleProto__RequestBlob init_value = MUMBLE_PROTO__REQUEST_BLOB__INIT;
  *message = init_value;
}
size_t mumble_proto__request_blob__get_packed_size
                     (const MumbleProto__RequestBlob *message)
{
  assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t mumble_proto__request_blob__pack
                     (const MumbleProto__RequestBlob *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t mumble_proto__request_blob__pack_to_buffer
                     (const MumbleProto__RequestBlob *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
MumbleProto__RequestBlob *
       mumble_proto__request_blob__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (MumbleProto__RequestBlob *)
     protobuf_c_message_unpack (&mumble_proto__request_blob__descriptor,
                                allocator, len, data);
}
void   mumble_proto__request_blob__free_unpacked
                     (MumbleProto__RequestBlob *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
{
  {
    "version",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Version, has_version),
    offsetof(MumbleProto__Version, version),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "release",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Version, release),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "os",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Version, os),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "os_version",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Version, os_version),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__version__field_indices_by_name[] = {
  2,   /* field[2] = os */
  3,   /* field[3] = os_version */
  1,   /* field[1] = release */
  0,   /* field[0] = version */
};
static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.Version",
  "Version",
  "MumbleProto__Version",
  "MumbleProto",
  sizeof(MumbleProto__Version),
  4,
  mumble_proto__version__field_descriptors,
  mumble_proto__version__field_indices_by_name,
  1,  mumble_proto__version__number_ranges,
  (ProtobufCMessageInit) mumble_proto__version__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
{
  {
    "packet",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UDPTunnel, packet),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
  0,   /* field[0] = packet */
};
static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UDPTunnel",
  "UDPTunnel",
  "MumbleProto__UDPTunnel",
  "MumbleProto",
  sizeof(MumbleProto__UDPTunnel),
  1,
  mumble_proto__udptunnel__field_descriptors,
  mumble_proto__udptunnel__field_indices_by_name,
  1,  mumble_proto__udptunnel__number_ranges,
  (ProtobufCMessageInit) mumble_proto__udptunnel__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__authenticate__opus__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[5] =
{
  {
    "username",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Authenticate, username),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "password",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Authenticate, password),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tokens",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(MumbleProto__Authenticate, n_tokens),
    offsetof(MumbleProto__Authenticate, tokens),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "celt_versions",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(MumbleProto__Authenticate, n_celt_versions),
    offsetof(MumbleProto__Authenticate, celt_versions),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "opus",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__Authenticate, has_opus),
    offsetof(MumbleProto__Authenticate, opus),
    NULL,
    &mumble_proto__authenticate__opus__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
  3,   /* field[3] = celt_versions */
  4,   /* field[4] = opus */
  1,   /* field[1] = password */
  2,   /* field[2] = tokens */
  0,   /* field[0] = username */
};
static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.Authenticate",
  "Authenticate",
  "MumbleProto__Authenticate",
  "MumbleProto",
  sizeof(MumbleProto__Authenticate),
  5,
  mumble_proto__authenticate__field_descriptors,
  mumble_proto__authenticate__field_indices_by_name,
  1,  mumble_proto__authenticate__number_ranges,
  (ProtobufCMessageInit) mumble_proto__authenticate__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
{
  {
    "timestamp",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(MumbleProto__Ping, has_timestamp),
    offsetof(MumbleProto__Ping, timestamp),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "good",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_good),
    offsetof(MumbleProto__Ping, good),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "late",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_late),
    offsetof(MumbleProto__Ping, late),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "lost",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_lost),
    offsetof(MumbleProto__Ping, lost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "resync",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_resync),
    offsetof(MumbleProto__Ping, resync),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_packets",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_udp_packets),
    offsetof(MumbleProto__Ping, udp_packets),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_packets",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__Ping, has_tcp_packets),
    offsetof(MumbleProto__Ping, tcp_packets),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_ping_avg",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__Ping, has_udp_ping_avg),
    offsetof(MumbleProto__Ping, udp_ping_avg),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_ping_var",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__Ping, has_udp_ping_var),
    offsetof(MumbleProto__Ping, udp_ping_var),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_ping_avg",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__Ping, has_tcp_ping_avg),
    offsetof(MumbleProto__Ping, tcp_ping_avg),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_ping_var",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__Ping, has_tcp_ping_var),
    offsetof(MumbleProto__Ping, tcp_ping_var),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__ping__field_indices_by_name[] = {
  1,   /* field[1] = good */
  2,   /* field[2] = late */
  3,   /* field[3] = lost */
  4,   /* field[4] = resync */
  6,   /* field[6] = tcp_packets */
  9,   /* field[9] = tcp_ping_avg */
  10,   /* field[10] = tcp_ping_var */
  0,   /* field[0] = timestamp */
  5,   /* field[5] = udp_packets */
  7,   /* field[7] = udp_ping_avg */
  8,   /* field[8] = udp_ping_var */
};
static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 11 }
};
const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.Ping",
  "Ping",
  "MumbleProto__Ping",
  "MumbleProto",
  sizeof(MumbleProto__Ping),
  11,
  mumble_proto__ping__field_descriptors,
  mumble_proto__ping__field_indices_by_name,
  1,  mumble_proto__ping__number_ranges,
  (ProtobufCMessageInit) mumble_proto__ping__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
{
  { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__None", 0 },
  { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion", 1 },
  { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername", 2 },
  { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW", 3 },
  { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW", 4 },
  { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse", 5 },
  { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull", 6 },
  { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate", 7 },
};
static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
{0, 0},{0, 8}
};
static const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
{
  { "InvalidUsername", 2 },
  { "NoCertificate", 7 },
  { "None", 0 },
  { "ServerFull", 6 },
  { "UsernameInUse", 5 },
  { "WrongServerPW", 4 },
  { "WrongUserPW", 3 },
  { "WrongVersion", 1 },
};
const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "MumbleProto.Reject.RejectType",
  "RejectType",
  "MumbleProto__Reject__RejectType",
  "MumbleProto",
  8,
  mumble_proto__reject__reject_type__enum_values_by_number,
  8,
  mumble_proto__reject__reject_type__enum_values_by_name,
  1,
  mumble_proto__reject__reject_type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
{
  {
    "type",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(MumbleProto__Reject, has_type),
    offsetof(MumbleProto__Reject, type),
    &mumble_proto__reject__reject_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "reason",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__Reject, reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__reject__field_indices_by_name[] = {
  1,   /* field[1] = reason */
  0,   /* field[0] = type */
};
static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.Reject",
  "Reject",
  "MumbleProto__Reject",
  "MumbleProto",
  sizeof(MumbleProto__Reject),
  2,
  mumble_proto__reject__field_descriptors,
  mumble_proto__reject__field_indices_by_name,
  1,  mumble_proto__reject__number_ranges,
  (ProtobufCMessageInit) mumble_proto__reject__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__server_config__field_descriptors[5] =
{
  {
    "max_bandwidth",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ServerConfig, has_max_bandwidth),
    offsetof(MumbleProto__ServerConfig, max_bandwidth),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "welcome_text",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ServerConfig, welcome_text),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "allow_html",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ServerConfig, has_allow_html),
    offsetof(MumbleProto__ServerConfig, allow_html),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "message_length",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ServerConfig, has_message_length),
    offsetof(MumbleProto__ServerConfig, message_length),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "image_message_length",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ServerConfig, has_image_message_length),
    offsetof(MumbleProto__ServerConfig, image_message_length),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__server_config__field_indices_by_name[] = {
  2,   /* field[2] = allow_html */
  4,   /* field[4] = image_message_length */
  0,   /* field[0] = max_bandwidth */
  3,   /* field[3] = message_length */
  1,   /* field[1] = welcome_text */
};
static const ProtobufCIntRange mumble_proto__server_config__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ServerConfig",
  "ServerConfig",
  "MumbleProto__ServerConfig",
  "MumbleProto",
  sizeof(MumbleProto__ServerConfig),
  5,
  mumble_proto__server_config__field_descriptors,
  mumble_proto__server_config__field_indices_by_name,
  1,  mumble_proto__server_config__number_ranges,
  (ProtobufCMessageInit) mumble_proto__server_config__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[4] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ServerSync, has_session),
    offsetof(MumbleProto__ServerSync, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "max_bandwidth",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ServerSync, has_max_bandwidth),
    offsetof(MumbleProto__ServerSync, max_bandwidth),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "welcome_text",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ServerSync, welcome_text),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "permissions",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(MumbleProto__ServerSync, has_permissions),
    offsetof(MumbleProto__ServerSync, permissions),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
  1,   /* field[1] = max_bandwidth */
  3,   /* field[3] = permissions */
  0,   /* field[0] = session */
  2,   /* field[2] = welcome_text */
};
static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ServerSync",
  "ServerSync",
  "MumbleProto__ServerSync",
  "MumbleProto",
  sizeof(MumbleProto__ServerSync),
  4,
  mumble_proto__server_sync__field_descriptors,
  mumble_proto__server_sync__field_indices_by_name,
  1,  mumble_proto__server_sync__number_ranges,
  (ProtobufCMessageInit) mumble_proto__server_sync__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
{
  {
    "channel_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ChannelRemove, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
  0,   /* field[0] = channel_id */
};
static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ChannelRemove",
  "ChannelRemove",
  "MumbleProto__ChannelRemove",
  "MumbleProto",
  sizeof(MumbleProto__ChannelRemove),
  1,
  mumble_proto__channel_remove__field_descriptors,
  mumble_proto__channel_remove__field_indices_by_name,
  1,  mumble_proto__channel_remove__number_ranges,
  (ProtobufCMessageInit) mumble_proto__channel_remove__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
static const int32_t mumble_proto__channel_state__position__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[10] =
{
  {
    "channel_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ChannelState, has_channel_id),
    offsetof(MumbleProto__ChannelState, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "parent",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ChannelState, has_parent),
    offsetof(MumbleProto__ChannelState, parent),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "name",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ChannelState, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "links",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ChannelState, n_links),
    offsetof(MumbleProto__ChannelState, links),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "description",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ChannelState, description),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "links_add",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ChannelState, n_links_add),
    offsetof(MumbleProto__ChannelState, links_add),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "links_remove",
    7,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ChannelState, n_links_remove),
    offsetof(MumbleProto__ChannelState, links_remove),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "temporary",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ChannelState, has_temporary),
    offsetof(MumbleProto__ChannelState, temporary),
    NULL,
    &mumble_proto__channel_state__temporary__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "position",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(MumbleProto__ChannelState, has_position),
    offsetof(MumbleProto__ChannelState, position),
    NULL,
    &mumble_proto__channel_state__position__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "description_hash",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__ChannelState, has_description_hash),
    offsetof(MumbleProto__ChannelState, description_hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
  0,   /* field[0] = channel_id */
  4,   /* field[4] = description */
  9,   /* field[9] = description_hash */
  3,   /* field[3] = links */
  5,   /* field[5] = links_add */
  6,   /* field[6] = links_remove */
  2,   /* field[2] = name */
  1,   /* field[1] = parent */
  8,   /* field[8] = position */
  7,   /* field[7] = temporary */
};
static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 10 }
};
const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ChannelState",
  "ChannelState",
  "MumbleProto__ChannelState",
  "MumbleProto",
  sizeof(MumbleProto__ChannelState),
  10,
  mumble_proto__channel_state__field_descriptors,
  mumble_proto__channel_state__field_indices_by_name,
  1,  mumble_proto__channel_state__number_ranges,
  (ProtobufCMessageInit) mumble_proto__channel_state__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserRemove, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "actor",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserRemove, has_actor),
    offsetof(MumbleProto__UserRemove, actor),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "reason",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserRemove, reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ban",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserRemove, has_ban),
    offsetof(MumbleProto__UserRemove, ban),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
  1,   /* field[1] = actor */
  3,   /* field[3] = ban */
  2,   /* field[2] = reason */
  0,   /* field[0] = session */
};
static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserRemove",
  "UserRemove",
  "MumbleProto__UserRemove",
  "MumbleProto",
  sizeof(MumbleProto__UserRemove),
  4,
  mumble_proto__user_remove__field_descriptors,
  mumble_proto__user_remove__field_indices_by_name,
  1,  mumble_proto__user_remove__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_remove__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[19] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserState, has_session),
    offsetof(MumbleProto__UserState, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "actor",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserState, has_actor),
    offsetof(MumbleProto__UserState, actor),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "name",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserState, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_id",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserState, has_user_id),
    offsetof(MumbleProto__UserState, user_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_id",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserState, has_channel_id),
    offsetof(MumbleProto__UserState, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mute",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_mute),
    offsetof(MumbleProto__UserState, mute),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "deaf",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_deaf),
    offsetof(MumbleProto__UserState, deaf),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "suppress",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_suppress),
    offsetof(MumbleProto__UserState, suppress),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "self_mute",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_self_mute),
    offsetof(MumbleProto__UserState, self_mute),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "self_deaf",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_self_deaf),
    offsetof(MumbleProto__UserState, self_deaf),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "texture",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserState, has_texture),
    offsetof(MumbleProto__UserState, texture),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "plugin_context",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserState, has_plugin_context),
    offsetof(MumbleProto__UserState, plugin_context),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "plugin_identity",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserState, plugin_identity),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "comment",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserState, comment),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hash",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserState, hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "comment_hash",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserState, has_comment_hash),
    offsetof(MumbleProto__UserState, comment_hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "texture_hash",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserState, has_texture_hash),
    offsetof(MumbleProto__UserState, texture_hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "priority_speaker",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_priority_speaker),
    offsetof(MumbleProto__UserState, priority_speaker),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "recording",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserState, has_recording),
    offsetof(MumbleProto__UserState, recording),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
  1,   /* field[1] = actor */
  4,   /* field[4] = channel_id */
  13,   /* field[13] = comment */
  15,   /* field[15] = comment_hash */
  6,   /* field[6] = deaf */
  14,   /* field[14] = hash */
  5,   /* field[5] = mute */
  2,   /* field[2] = name */
  11,   /* field[11] = plugin_context */
  12,   /* field[12] = plugin_identity */
  17,   /* field[17] = priority_speaker */
  18,   /* field[18] = recording */
  9,   /* field[9] = self_deaf */
  8,   /* field[8] = self_mute */
  0,   /* field[0] = session */
  7,   /* field[7] = suppress */
  10,   /* field[10] = texture */
  16,   /* field[16] = texture_hash */
  3,   /* field[3] = user_id */
};
static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 19 }
};
const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserState",
  "UserState",
  "MumbleProto__UserState",
  "MumbleProto",
  sizeof(MumbleProto__UserState),
  19,
  mumble_proto__user_state__field_descriptors,
  mumble_proto__user_state__field_indices_by_name,
  1,  mumble_proto__user_state__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_state__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
{
  {
    "address",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, address),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mask",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, mask),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "name",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hash",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "reason",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "start",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__BanList__BanEntry, start),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "duration",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__BanList__BanEntry, has_duration),
    offsetof(MumbleProto__BanList__BanEntry, duration),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
  0,   /* field[0] = address */
  6,   /* field[6] = duration */
  3,   /* field[3] = hash */
  1,   /* field[1] = mask */
  2,   /* field[2] = name */
  4,   /* field[4] = reason */
  5,   /* field[5] = start */
};
static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.BanList.BanEntry",
  "BanEntry",
  "MumbleProto__BanList__BanEntry",
  "MumbleProto",
  sizeof(MumbleProto__BanList__BanEntry),
  7,
  mumble_proto__ban_list__ban_entry__field_descriptors,
  mumble_proto__ban_list__ban_entry__field_indices_by_name,
  1,  mumble_proto__ban_list__ban_entry__number_ranges,
  (ProtobufCMessageInit) mumble_proto__ban_list__ban_entry__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
{
  {
    "bans",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MumbleProto__BanList, n_bans),
    offsetof(MumbleProto__BanList, bans),
    &mumble_proto__ban_list__ban_entry__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "query",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__BanList, has_query),
    offsetof(MumbleProto__BanList, query),
    NULL,
    &mumble_proto__ban_list__query__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
  0,   /* field[0] = bans */
  1,   /* field[1] = query */
};
static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.BanList",
  "BanList",
  "MumbleProto__BanList",
  "MumbleProto",
  sizeof(MumbleProto__BanList),
  2,
  mumble_proto__ban_list__field_descriptors,
  mumble_proto__ban_list__field_indices_by_name,
  1,  mumble_proto__ban_list__number_ranges,
  (ProtobufCMessageInit) mumble_proto__ban_list__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
{
  {
    "actor",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__TextMessage, has_actor),
    offsetof(MumbleProto__TextMessage, actor),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__TextMessage, n_session),
    offsetof(MumbleProto__TextMessage, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_id",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__TextMessage, n_channel_id),
    offsetof(MumbleProto__TextMessage, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tree_id",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__TextMessage, n_tree_id),
    offsetof(MumbleProto__TextMessage, tree_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "message",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__TextMessage, message),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
  0,   /* field[0] = actor */
  2,   /* field[2] = channel_id */
  4,   /* field[4] = message */
  1,   /* field[1] = session */
  3,   /* field[3] = tree_id */
};
static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.TextMessage",
  "TextMessage",
  "MumbleProto__TextMessage",
  "MumbleProto",
  sizeof(MumbleProto__TextMessage),
  5,
  mumble_proto__text_message__field_descriptors,
  mumble_proto__text_message__field_indices_by_name,
  1,  mumble_proto__text_message__number_ranges,
  (ProtobufCMessageInit) mumble_proto__text_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[11] =
{
  { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text", 0 },
  { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission", 1 },
  { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser", 2 },
  { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName", 3 },
  { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong", 4 },
  { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
  { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel", 6 },
  { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate", 7 },
  { "UserName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName", 8 },
  { "ChannelFull", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull", 9 },
  { "NestingLimit", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NestingLimit", 10 },
};
static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
{0, 0},{0, 11}
};
static const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[11] =
{
  { "ChannelFull", 9 },
  { "ChannelName", 3 },
  { "H9K", 5 },
  { "MissingCertificate", 7 },
  { "NestingLimit", 10 },
  { "Permission", 1 },
  { "SuperUser", 2 },
  { "TemporaryChannel", 6 },
  { "Text", 0 },
  { "TextTooLong", 4 },
  { "UserName", 8 },
};
const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "MumbleProto.PermissionDenied.DenyType",
  "DenyType",
  "MumbleProto__PermissionDenied__DenyType",
  "MumbleProto",
  11,
  mumble_proto__permission_denied__deny_type__enum_values_by_number,
  11,
  mumble_proto__permission_denied__deny_type__enum_values_by_name,
  1,
  mumble_proto__permission_denied__deny_type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[6] =
{
  {
    "permission",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__PermissionDenied, has_permission),
    offsetof(MumbleProto__PermissionDenied, permission),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_id",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__PermissionDenied, has_channel_id),
    offsetof(MumbleProto__PermissionDenied, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__PermissionDenied, has_session),
    offsetof(MumbleProto__PermissionDenied, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "reason",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__PermissionDenied, reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "type",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(MumbleProto__PermissionDenied, has_type),
    offsetof(MumbleProto__PermissionDenied, type),
    &mumble_proto__permission_denied__deny_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "name",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__PermissionDenied, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
  1,   /* field[1] = channel_id */
  5,   /* field[5] = name */
  0,   /* field[0] = permission */
  3,   /* field[3] = reason */
  2,   /* field[2] = session */
  4,   /* field[4] = type */
};
static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.PermissionDenied",
  "PermissionDenied",
  "MumbleProto__PermissionDenied",
  "MumbleProto",
  sizeof(MumbleProto__PermissionDenied),
  6,
  mumble_proto__permission_denied__field_descriptors,
  mumble_proto__permission_denied__field_indices_by_name,
  1,  mumble_proto__permission_denied__number_ranges,
  (ProtobufCMessageInit) mumble_proto__permission_denied__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ACL__ChanGroup, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inherited",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanGroup, has_inherited),
    offsetof(MumbleProto__ACL__ChanGroup, inherited),
    NULL,
    &mumble_proto__acl__chan_group__inherited__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inherit",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanGroup, has_inherit),
    offsetof(MumbleProto__ACL__ChanGroup, inherit),
    NULL,
    &mumble_proto__acl__chan_group__inherit__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inheritable",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanGroup, has_inheritable),
    offsetof(MumbleProto__ACL__ChanGroup, inheritable),
    NULL,
    &mumble_proto__acl__chan_group__inheritable__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "add",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanGroup, n_add),
    offsetof(MumbleProto__ACL__ChanGroup, add),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remove",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanGroup, n_remove),
    offsetof(MumbleProto__ACL__ChanGroup, remove),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inherited_members",
    7,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanGroup, n_inherited_members),
    offsetof(MumbleProto__ACL__ChanGroup, inherited_members),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
  4,   /* field[4] = add */
  2,   /* field[2] = inherit */
  3,   /* field[3] = inheritable */
  1,   /* field[1] = inherited */
  6,   /* field[6] = inherited_members */
  0,   /* field[0] = name */
  5,   /* field[5] = remove */
};
static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ACL.ChanGroup",
  "ChanGroup",
  "MumbleProto__ACL__ChanGroup",
  "MumbleProto",
  sizeof(MumbleProto__ACL__ChanGroup),
  7,
  mumble_proto__acl__chan_group__field_descriptors,
  mumble_proto__acl__chan_group__field_indices_by_name,
  1,  mumble_proto__acl__chan_group__number_ranges,
  (ProtobufCMessageInit) mumble_proto__acl__chan_group__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
{
  {
    "apply_here",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanACL, has_apply_here),
    offsetof(MumbleProto__ACL__ChanACL, apply_here),
    NULL,
    &mumble_proto__acl__chan_acl__apply_here__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "apply_subs",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanACL, has_apply_subs),
    offsetof(MumbleProto__ACL__ChanACL, apply_subs),
    NULL,
    &mumble_proto__acl__chan_acl__apply_subs__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inherited",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL__ChanACL, has_inherited),
    offsetof(MumbleProto__ACL__ChanACL, inherited),
    NULL,
    &mumble_proto__acl__chan_acl__inherited__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_id",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanACL, has_user_id),
    offsetof(MumbleProto__ACL__ChanACL, user_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "group",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ACL__ChanACL, group),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "grant",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanACL, has_grant),
    offsetof(MumbleProto__ACL__ChanACL, grant),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "deny",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ACL__ChanACL, has_deny),
    offsetof(MumbleProto__ACL__ChanACL, deny),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
  0,   /* field[0] = apply_here */
  1,   /* field[1] = apply_subs */
  6,   /* field[6] = deny */
  5,   /* field[5] = grant */
  4,   /* field[4] = group */
  2,   /* field[2] = inherited */
  3,   /* field[3] = user_id */
};
static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ACL.ChanACL",
  "ChanACL",
  "MumbleProto__ACL__ChanACL",
  "MumbleProto",
  sizeof(MumbleProto__ACL__ChanACL),
  7,
  mumble_proto__acl__chan_acl__field_descriptors,
  mumble_proto__acl__chan_acl__field_indices_by_name,
  1,  mumble_proto__acl__chan_acl__number_ranges,
  (ProtobufCMessageInit) mumble_proto__acl__chan_acl__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
{
  {
    "channel_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ACL, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "inherit_acls",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL, has_inherit_acls),
    offsetof(MumbleProto__ACL, inherit_acls),
    NULL,
    &mumble_proto__acl__inherit_acls__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "groups",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MumbleProto__ACL, n_groups),
    offsetof(MumbleProto__ACL, groups),
    &mumble_proto__acl__chan_group__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "acls",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MumbleProto__ACL, n_acls),
    offsetof(MumbleProto__ACL, acls),
    &mumble_proto__acl__chan_acl__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "query",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__ACL, has_query),
    offsetof(MumbleProto__ACL, query),
    NULL,
    &mumble_proto__acl__query__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__acl__field_indices_by_name[] = {
  3,   /* field[3] = acls */
  0,   /* field[0] = channel_id */
  2,   /* field[2] = groups */
  1,   /* field[1] = inherit_acls */
  4,   /* field[4] = query */
};
static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ACL",
  "ACL",
  "MumbleProto__ACL",
  "MumbleProto",
  sizeof(MumbleProto__ACL),
  5,
  mumble_proto__acl__field_descriptors,
  mumble_proto__acl__field_indices_by_name,
  1,  mumble_proto__acl__number_ranges,
  (ProtobufCMessageInit) mumble_proto__acl__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
{
  {
    "ids",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__QueryUsers, n_ids),
    offsetof(MumbleProto__QueryUsers, ids),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "names",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(MumbleProto__QueryUsers, n_names),
    offsetof(MumbleProto__QueryUsers, names),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
  0,   /* field[0] = ids */
  1,   /* field[1] = names */
};
static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.QueryUsers",
  "QueryUsers",
  "MumbleProto__QueryUsers",
  "MumbleProto",
  sizeof(MumbleProto__QueryUsers),
  2,
  mumble_proto__query_users__field_descriptors,
  mumble_proto__query_users__field_indices_by_name,
  1,  mumble_proto__query_users__number_ranges,
  (ProtobufCMessageInit) mumble_proto__query_users__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
{
  {
    "key",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__CryptSetup, has_key),
    offsetof(MumbleProto__CryptSetup, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "client_nonce",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__CryptSetup, has_client_nonce),
    offsetof(MumbleProto__CryptSetup, client_nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "server_nonce",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__CryptSetup, has_server_nonce),
    offsetof(MumbleProto__CryptSetup, server_nonce),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
  1,   /* field[1] = client_nonce */
  0,   /* field[0] = key */
  2,   /* field[2] = server_nonce */
};
static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.CryptSetup",
  "CryptSetup",
  "MumbleProto__CryptSetup",
  "MumbleProto",
  sizeof(MumbleProto__CryptSetup),
  3,
  mumble_proto__crypt_setup__field_descriptors,
  mumble_proto__crypt_setup__field_indices_by_name,
  1,  mumble_proto__crypt_setup__number_ranges,
  (ProtobufCMessageInit) mumble_proto__crypt_setup__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue mumble_proto__context_action_modify__context__enum_values_by_number[3] =
{
  { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Server", 1 },
  { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Channel", 2 },
  { "User", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__User", 4 },
};
static const ProtobufCIntRange mumble_proto__context_action_modify__context__value_ranges[] = {
{1, 0},{4, 2},{0, 3}
};
static const ProtobufCEnumValueIndex mumble_proto__context_action_modify__context__enum_values_by_name[3] =
{
  { "Channel", 1 },
  { "Server", 0 },
  { "User", 2 },
};
const ProtobufCEnumDescriptor mumble_proto__context_action_modify__context__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "MumbleProto.ContextActionModify.Context",
  "Context",
  "MumbleProto__ContextActionModify__Context",
  "MumbleProto",
  3,
  mumble_proto__context_action_modify__context__enum_values_by_number,
  3,
  mumble_proto__context_action_modify__context__enum_values_by_name,
  2,
  mumble_proto__context_action_modify__context__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCEnumValue mumble_proto__context_action_modify__operation__enum_values_by_number[2] =
{
  { "Add", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add", 0 },
  { "Remove", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Remove", 1 },
};
static const ProtobufCIntRange mumble_proto__context_action_modify__operation__value_ranges[] = {
{0, 0},{0, 2}
};
static const ProtobufCEnumValueIndex mumble_proto__context_action_modify__operation__enum_values_by_name[2] =
{
  { "Add", 0 },
  { "Remove", 1 },
};
const ProtobufCEnumDescriptor mumble_proto__context_action_modify__operation__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "MumbleProto.ContextActionModify.Operation",
  "Operation",
  "MumbleProto__ContextActionModify__Operation",
  "MumbleProto",
  2,
  mumble_proto__context_action_modify__operation__enum_values_by_number,
  2,
  mumble_proto__context_action_modify__operation__enum_values_by_name,
  1,
  mumble_proto__context_action_modify__operation__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor mumble_proto__context_action_modify__field_descriptors[4] =
{
  {
    "action",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ContextActionModify, action),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "text",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ContextActionModify, text),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "context",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ContextActionModify, has_context),
    offsetof(MumbleProto__ContextActionModify, context),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "operation",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(MumbleProto__ContextActionModify, has_operation),
    offsetof(MumbleProto__ContextActionModify, operation),
    &mumble_proto__context_action_modify__operation__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__context_action_modify__field_indices_by_name[] = {
  0,   /* field[0] = action */
  2,   /* field[2] = context */
  3,   /* field[3] = operation */
  1,   /* field[1] = text */
};
static const ProtobufCIntRange mumble_proto__context_action_modify__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ContextActionModify",
  "ContextActionModify",
  "MumbleProto__ContextActionModify",
  "MumbleProto",
  sizeof(MumbleProto__ContextActionModify),
  4,
  mumble_proto__context_action_modify__field_descriptors,
  mumble_proto__context_action_modify__field_indices_by_name,
  1,  mumble_proto__context_action_modify__number_ranges,
  (ProtobufCMessageInit) mumble_proto__context_action_modify__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ContextAction, has_session),
    offsetof(MumbleProto__ContextAction, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_id",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__ContextAction, has_channel_id),
    offsetof(MumbleProto__ContextAction, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "action",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__ContextAction, action),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
  2,   /* field[2] = action */
  1,   /* field[1] = channel_id */
  0,   /* field[0] = session */
};
static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.ContextAction",
  "ContextAction",
  "MumbleProto__ContextAction",
  "MumbleProto",
  sizeof(MumbleProto__ContextAction),
  3,
  mumble_proto__context_action__field_descriptors,
  mumble_proto__context_action__field_indices_by_name,
  1,  mumble_proto__context_action__number_ranges,
  (ProtobufCMessageInit) mumble_proto__context_action__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
{
  {
    "user_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserList__User, user_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "name",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserList__User, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
  1,   /* field[1] = name */
  0,   /* field[0] = user_id */
};
static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserList.User",
  "User",
  "MumbleProto__UserList__User",
  "MumbleProto",
  sizeof(MumbleProto__UserList__User),
  2,
  mumble_proto__user_list__user__field_descriptors,
  mumble_proto__user_list__user__field_indices_by_name,
  1,  mumble_proto__user_list__user__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_list__user__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
{
  {
    "users",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MumbleProto__UserList, n_users),
    offsetof(MumbleProto__UserList, users),
    &mumble_proto__user_list__user__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
  0,   /* field[0] = users */
};
static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserList",
  "UserList",
  "MumbleProto__UserList",
  "MumbleProto",
  sizeof(MumbleProto__UserList),
  1,
  mumble_proto__user_list__field_descriptors,
  mumble_proto__user_list__field_indices_by_name,
  1,  mumble_proto__user_list__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_list__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__VoiceTarget__Target, n_session),
    offsetof(MumbleProto__VoiceTarget__Target, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_id",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__VoiceTarget__Target, has_channel_id),
    offsetof(MumbleProto__VoiceTarget__Target, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "group",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__VoiceTarget__Target, group),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "links",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__VoiceTarget__Target, has_links),
    offsetof(MumbleProto__VoiceTarget__Target, links),
    NULL,
    &mumble_proto__voice_target__target__links__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "children",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__VoiceTarget__Target, has_children),
    offsetof(MumbleProto__VoiceTarget__Target, children),
    NULL,
    &mumble_proto__voice_target__target__children__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
  1,   /* field[1] = channel_id */
  4,   /* field[4] = children */
  2,   /* field[2] = group */
  3,   /* field[3] = links */
  0,   /* field[0] = session */
};
static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.VoiceTarget.Target",
  "Target",
  "MumbleProto__VoiceTarget__Target",
  "MumbleProto",
  sizeof(MumbleProto__VoiceTarget__Target),
  5,
  mumble_proto__voice_target__target__field_descriptors,
  mumble_proto__voice_target__target__field_indices_by_name,
  1,  mumble_proto__voice_target__target__number_ranges,
  (ProtobufCMessageInit) mumble_proto__voice_target__target__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
{
  {
    "id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__VoiceTarget, has_id),
    offsetof(MumbleProto__VoiceTarget, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "targets",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(MumbleProto__VoiceTarget, n_targets),
    offsetof(MumbleProto__VoiceTarget, targets),
    &mumble_proto__voice_target__target__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
  0,   /* field[0] = id */
  1,   /* field[1] = targets */
};
static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.VoiceTarget",
  "VoiceTarget",
  "MumbleProto__VoiceTarget",
  "MumbleProto",
  sizeof(MumbleProto__VoiceTarget),
  2,
  mumble_proto__voice_target__field_descriptors,
  mumble_proto__voice_target__field_indices_by_name,
  1,  mumble_proto__voice_target__number_ranges,
  (ProtobufCMessageInit) mumble_proto__voice_target__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
{
  {
    "channel_id",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__PermissionQuery, has_channel_id),
    offsetof(MumbleProto__PermissionQuery, channel_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "permissions",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__PermissionQuery, has_permissions),
    offsetof(MumbleProto__PermissionQuery, permissions),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "flush",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__PermissionQuery, has_flush),
    offsetof(MumbleProto__PermissionQuery, flush),
    NULL,
    &mumble_proto__permission_query__flush__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
  0,   /* field[0] = channel_id */
  2,   /* field[2] = flush */
  1,   /* field[1] = permissions */
};
static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.PermissionQuery",
  "PermissionQuery",
  "MumbleProto__PermissionQuery",
  "MumbleProto",
  sizeof(MumbleProto__PermissionQuery),
  3,
  mumble_proto__permission_query__field_descriptors,
  mumble_proto__permission_query__field_indices_by_name,
  1,  mumble_proto__permission_query__number_ranges,
  (ProtobufCMessageInit) mumble_proto__permission_query__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
static const protobuf_c_boolean mumble_proto__codec_version__opus__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[4] =
{
  {
    "alpha",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__CodecVersion, alpha),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "beta",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__CodecVersion, beta),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prefer_alpha",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__CodecVersion, prefer_alpha),
    NULL,
    &mumble_proto__codec_version__prefer_alpha__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "opus",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__CodecVersion, has_opus),
    offsetof(MumbleProto__CodecVersion, opus),
    NULL,
    &mumble_proto__codec_version__opus__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
  0,   /* field[0] = alpha */
  1,   /* field[1] = beta */
  3,   /* field[3] = opus */
  2,   /* field[2] = prefer_alpha */
};
static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.CodecVersion",
  "CodecVersion",
  "MumbleProto__CodecVersion",
  "MumbleProto",
  sizeof(MumbleProto__CodecVersion),
  4,
  mumble_proto__codec_version__field_descriptors,
  mumble_proto__codec_version__field_indices_by_name,
  1,  mumble_proto__codec_version__number_ranges,
  (ProtobufCMessageInit) mumble_proto__codec_version__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__user_stats__stats__field_descriptors[4] =
{
  {
    "good",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats__Stats, has_good),
    offsetof(MumbleProto__UserStats__Stats, good),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "late",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats__Stats, has_late),
    offsetof(MumbleProto__UserStats__Stats, late),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "lost",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats__Stats, has_lost),
    offsetof(MumbleProto__UserStats__Stats, lost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "resync",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats__Stats, has_resync),
    offsetof(MumbleProto__UserStats__Stats, resync),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_stats__stats__field_indices_by_name[] = {
  0,   /* field[0] = good */
  1,   /* field[1] = late */
  2,   /* field[2] = lost */
  3,   /* field[3] = resync */
};
static const ProtobufCIntRange mumble_proto__user_stats__stats__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserStats.Stats",
  "Stats",
  "MumbleProto__UserStats__Stats",
  "MumbleProto",
  sizeof(MumbleProto__UserStats__Stats),
  4,
  mumble_proto__user_stats__stats__field_descriptors,
  mumble_proto__user_stats__stats__field_indices_by_name,
  1,  mumble_proto__user_stats__stats__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_stats__stats__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean mumble_proto__user_stats__stats_only__default_value = 0;
static const protobuf_c_boolean mumble_proto__user_stats__strong_certificate__default_value = 0;
static const protobuf_c_boolean mumble_proto__user_stats__opus__default_value = 0;
static const ProtobufCFieldDescriptor mumble_proto__user_stats__field_descriptors[19] =
{
  {
    "session",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_session),
    offsetof(MumbleProto__UserStats, session),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "stats_only",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserStats, has_stats_only),
    offsetof(MumbleProto__UserStats, stats_only),
    NULL,
    &mumble_proto__user_stats__stats_only__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "certificates",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserStats, n_certificates),
    offsetof(MumbleProto__UserStats, certificates),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "from_client",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserStats, from_client),
    &mumble_proto__user_stats__stats__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "from_server",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserStats, from_server),
    &mumble_proto__user_stats__stats__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_packets",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_udp_packets),
    offsetof(MumbleProto__UserStats, udp_packets),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_packets",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_tcp_packets),
    offsetof(MumbleProto__UserStats, tcp_packets),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_ping_avg",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__UserStats, has_udp_ping_avg),
    offsetof(MumbleProto__UserStats, udp_ping_avg),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "udp_ping_var",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__UserStats, has_udp_ping_var),
    offsetof(MumbleProto__UserStats, udp_ping_var),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_ping_avg",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__UserStats, has_tcp_ping_avg),
    offsetof(MumbleProto__UserStats, tcp_ping_avg),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tcp_ping_var",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(MumbleProto__UserStats, has_tcp_ping_var),
    offsetof(MumbleProto__UserStats, tcp_ping_var),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(MumbleProto__UserStats, version),
    &mumble_proto__version__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "celt_versions",
    13,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(MumbleProto__UserStats, n_celt_versions),
    offsetof(MumbleProto__UserStats, celt_versions),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "address",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(MumbleProto__UserStats, has_address),
    offsetof(MumbleProto__UserStats, address),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bandwidth",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_bandwidth),
    offsetof(MumbleProto__UserStats, bandwidth),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "onlinesecs",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_onlinesecs),
    offsetof(MumbleProto__UserStats, onlinesecs),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "idlesecs",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__UserStats, has_idlesecs),
    offsetof(MumbleProto__UserStats, idlesecs),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "strong_certificate",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserStats, has_strong_certificate),
    offsetof(MumbleProto__UserStats, strong_certificate),
    NULL,
    &mumble_proto__user_stats__strong_certificate__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "opus",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__UserStats, has_opus),
    offsetof(MumbleProto__UserStats, opus),
    NULL,
    &mumble_proto__user_stats__opus__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__user_stats__field_indices_by_name[] = {
  13,   /* field[13] = address */
  14,   /* field[14] = bandwidth */
  12,   /* field[12] = celt_versions */
  2,   /* field[2] = certificates */
  3,   /* field[3] = from_client */
  4,   /* field[4] = from_server */
  16,   /* field[16] = idlesecs */
  15,   /* field[15] = onlinesecs */
  18,   /* field[18] = opus */
  0,   /* field[0] = session */
  1,   /* field[1] = stats_only */
  17,   /* field[17] = strong_certificate */
  6,   /* field[6] = tcp_packets */
  9,   /* field[9] = tcp_ping_avg */
  10,   /* field[10] = tcp_ping_var */
  5,   /* field[5] = udp_packets */
  7,   /* field[7] = udp_ping_avg */
  8,   /* field[8] = udp_ping_var */
  11,   /* field[11] = version */
};
static const ProtobufCIntRange mumble_proto__user_stats__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 19 }
};
const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.UserStats",
  "UserStats",
  "MumbleProto__UserStats",
  "MumbleProto",
  sizeof(MumbleProto__UserStats),
  19,
  mumble_proto__user_stats__field_descriptors,
  mumble_proto__user_stats__field_indices_by_name,
  1,  mumble_proto__user_stats__number_ranges,
  (ProtobufCMessageInit) mumble_proto__user_stats__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__suggest_config__field_descriptors[3] =
{
  {
    "version",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__SuggestConfig, has_version),
    offsetof(MumbleProto__SuggestConfig, version),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "positional",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__SuggestConfig, has_positional),
    offsetof(MumbleProto__SuggestConfig, positional),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "push_to_talk",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(MumbleProto__SuggestConfig, has_push_to_talk),
    offsetof(MumbleProto__SuggestConfig, push_to_talk),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__suggest_config__field_indices_by_name[] = {
  1,   /* field[1] = positional */
  2,   /* field[2] = push_to_talk */
  0,   /* field[0] = version */
};
static const ProtobufCIntRange mumble_proto__suggest_config__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.SuggestConfig",
  "SuggestConfig",
  "MumbleProto__SuggestConfig",
  "MumbleProto",
  sizeof(MumbleProto__SuggestConfig),
  3,
  mumble_proto__suggest_config__field_descriptors,
  mumble_proto__suggest_config__field_indices_by_name,
  1,  mumble_proto__suggest_config__number_ranges,
  (ProtobufCMessageInit) mumble_proto__suggest_config__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor mumble_proto__request_blob__field_descriptors[3] =
{
  {
    "session_texture",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__RequestBlob, n_session_texture),
    offsetof(MumbleProto__RequestBlob, session_texture),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_comment",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__RequestBlob, n_session_comment),
    offsetof(MumbleProto__RequestBlob, session_comment),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "channel_description",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(MumbleProto__RequestBlob, n_channel_description),
    offsetof(MumbleProto__RequestBlob, channel_description),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned mumble_proto__request_blob__field_indices_by_name[] = {
  2,   /* field[2] = channel_description */
  1,   /* field[1] = session_comment */
  0,   /* field[0] = session_texture */
};
static const ProtobufCIntRange mumble_proto__request_blob__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "MumbleProto.RequestBlob",
  "RequestBlob",
  "MumbleProto__RequestBlob",
  "MumbleProto",
  sizeof(MumbleProto__RequestBlob),
  3,
  mumble_proto__request_blob__field_descriptors,
  mumble_proto__request_blob__field_indices_by_name,
  1,  mumble_proto__request_blob__number_ranges,
  (ProtobufCMessageInit) mumble_proto__request_blob__init,
  NULL,NULL,NULL    /* reserved[123] */
};
