src/Mumble.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2
   3 /* Do not generate deprecated warnings for self */
   4 #ifndef PROTOBUF_C_NO_DEPRECATED
   5 #define PROTOBUF_C_NO_DEPRECATED
   6 #endif
   7
   8 #include "Mumble.pb-c.h"
   9 void   mumble_proto__version__init
  10                      (MumbleProto__Version         *message)
  11 {
  12   static MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
  13   *message = init_value;
  14 }
  15 size_t mumble_proto__version__get_packed_size
  16                      (const MumbleProto__Version *message)
  17 {
  18   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  19   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  20 }
  21 size_t mumble_proto__version__pack
  22                      (const MumbleProto__Version *message,
  23                       uint8_t       *out)
  24 {
  25   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  26   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  27 }
  28 size_t mumble_proto__version__pack_to_buffer
  29                      (const MumbleProto__Version *message,
  30                       ProtobufCBuffer *buffer)
  31 {
  32   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  33   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  34 }
  35 MumbleProto__Version *
  36        mumble_proto__version__unpack
  37                      (ProtobufCAllocator  *allocator,
  38                       size_t               len,
  39                       const uint8_t       *data)
  40 {
  41   return (MumbleProto__Version *)
  42      protobuf_c_message_unpack (&mumble_proto__version__descriptor,
  43                                 allocator, len, data);
  44 }
  45 void   mumble_proto__version__free_unpacked
  46                      (MumbleProto__Version *message,
  47                       ProtobufCAllocator *allocator)
  48 {
  49   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  50   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  51 }
  52 void   mumble_proto__udptunnel__init
  53                      (MumbleProto__UDPTunnel         *message)
  54 {
  55   static MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
  56   *message = init_value;
  57 }
  58 size_t mumble_proto__udptunnel__get_packed_size
  59                      (const MumbleProto__UDPTunnel *message)
  60 {
  61   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  62   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  63 }
  64 size_t mumble_proto__udptunnel__pack
  65                      (const MumbleProto__UDPTunnel *message,
  66                       uint8_t       *out)
  67 {
  68   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  69   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  70 }
  71 size_t mumble_proto__udptunnel__pack_to_buffer
  72                      (const MumbleProto__UDPTunnel *message,
  73                       ProtobufCBuffer *buffer)
  74 {
  75   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  76   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  77 }
  78 MumbleProto__UDPTunnel *
  79        mumble_proto__udptunnel__unpack
  80                      (ProtobufCAllocator  *allocator,
  81                       size_t               len,
  82                       const uint8_t       *data)
  83 {
  84   return (MumbleProto__UDPTunnel *)
  85      protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
  86                                 allocator, len, data);
  87 }
  88 void   mumble_proto__udptunnel__free_unpacked
  89                      (MumbleProto__UDPTunnel *message,
  90                       ProtobufCAllocator *allocator)
  91 {
  92   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  93   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  94 }
  95 void   mumble_proto__authenticate__init
  96                      (MumbleProto__Authenticate         *message)
  97 {
  98   static MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
  99   *message = init_value;
 100 }
 101 size_t mumble_proto__authenticate__get_packed_size
 102                      (const MumbleProto__Authenticate *message)
 103 {
 104   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 105   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 106 }
 107 size_t mumble_proto__authenticate__pack
 108                      (const MumbleProto__Authenticate *message,
 109                       uint8_t       *out)
 110 {
 111   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 112   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 113 }
 114 size_t mumble_proto__authenticate__pack_to_buffer
 115                      (const MumbleProto__Authenticate *message,
 116                       ProtobufCBuffer *buffer)
 117 {
 118   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 119   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 120 }
 121 MumbleProto__Authenticate *
 122        mumble_proto__authenticate__unpack
 123                      (ProtobufCAllocator  *allocator,
 124                       size_t               len,
 125                       const uint8_t       *data)
 126 {
 127   return (MumbleProto__Authenticate *)
 128      protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
 129                                 allocator, len, data);
 130 }
 131 void   mumble_proto__authenticate__free_unpacked
 132                      (MumbleProto__Authenticate *message,
 133                       ProtobufCAllocator *allocator)
 134 {
 135   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 136   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 137 }
 138 void   mumble_proto__ping__init
 139                      (MumbleProto__Ping         *message)
 140 {
 141   static MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
 142   *message = init_value;
 143 }
 144 size_t mumble_proto__ping__get_packed_size
 145                      (const MumbleProto__Ping *message)
 146 {
 147   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 148   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 149 }
 150 size_t mumble_proto__ping__pack
 151                      (const MumbleProto__Ping *message,
 152                       uint8_t       *out)
 153 {
 154   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 155   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 156 }
 157 size_t mumble_proto__ping__pack_to_buffer
 158                      (const MumbleProto__Ping *message,
 159                       ProtobufCBuffer *buffer)
 160 {
 161   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 162   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 163 }
 164 MumbleProto__Ping *
 165        mumble_proto__ping__unpack
 166                      (ProtobufCAllocator  *allocator,
 167                       size_t               len,
 168                       const uint8_t       *data)
 169 {
 170   return (MumbleProto__Ping *)
 171      protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
 172                                 allocator, len, data);
 173 }
 174 void   mumble_proto__ping__free_unpacked
 175                      (MumbleProto__Ping *message,
 176                       ProtobufCAllocator *allocator)
 177 {
 178   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 179   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 180 }
 181 void   mumble_proto__reject__init
 182                      (MumbleProto__Reject         *message)
 183 {
 184   static MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
 185   *message = init_value;
 186 }
 187 size_t mumble_proto__reject__get_packed_size
 188                      (const MumbleProto__Reject *message)
 189 {
 190   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 191   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 192 }
 193 size_t mumble_proto__reject__pack
 194                      (const MumbleProto__Reject *message,
 195                       uint8_t       *out)
 196 {
 197   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 198   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 199 }
 200 size_t mumble_proto__reject__pack_to_buffer
 201                      (const MumbleProto__Reject *message,
 202                       ProtobufCBuffer *buffer)
 203 {
 204   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 205   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 206 }
 207 MumbleProto__Reject *
 208        mumble_proto__reject__unpack
 209                      (ProtobufCAllocator  *allocator,
 210                       size_t               len,
 211                       const uint8_t       *data)
 212 {
 213   return (MumbleProto__Reject *)
 214      protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
 215                                 allocator, len, data);
 216 }
 217 void   mumble_proto__reject__free_unpacked
 218                      (MumbleProto__Reject *message,
 219                       ProtobufCAllocator *allocator)
 220 {
 221   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 222   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 223 }
 224 void   mumble_proto__server_sync__init
 225                      (MumbleProto__ServerSync         *message)
 226 {
 227   static MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
 228   *message = init_value;
 229 }
 230 size_t mumble_proto__server_sync__get_packed_size
 231                      (const MumbleProto__ServerSync *message)
 232 {
 233   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 234   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 235 }
 236 size_t mumble_proto__server_sync__pack
 237                      (const MumbleProto__ServerSync *message,
 238                       uint8_t       *out)
 239 {
 240   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 241   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 242 }
 243 size_t mumble_proto__server_sync__pack_to_buffer
 244                      (const MumbleProto__ServerSync *message,
 245                       ProtobufCBuffer *buffer)
 246 {
 247   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 248   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 249 }
 250 MumbleProto__ServerSync *
 251        mumble_proto__server_sync__unpack
 252                      (ProtobufCAllocator  *allocator,
 253                       size_t               len,
 254                       const uint8_t       *data)
 255 {
 256   return (MumbleProto__ServerSync *)
 257      protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
 258                                 allocator, len, data);
 259 }
 260 void   mumble_proto__server_sync__free_unpacked
 261                      (MumbleProto__ServerSync *message,
 262                       ProtobufCAllocator *allocator)
 263 {
 264   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 265   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 266 }
 267 void   mumble_proto__channel_remove__init
 268                      (MumbleProto__ChannelRemove         *message)
 269 {
 270   static MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
 271   *message = init_value;
 272 }
 273 size_t mumble_proto__channel_remove__get_packed_size
 274                      (const MumbleProto__ChannelRemove *message)
 275 {
 276   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 277   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 278 }
 279 size_t mumble_proto__channel_remove__pack
 280                      (const MumbleProto__ChannelRemove *message,
 281                       uint8_t       *out)
 282 {
 283   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 284   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 285 }
 286 size_t mumble_proto__channel_remove__pack_to_buffer
 287                      (const MumbleProto__ChannelRemove *message,
 288                       ProtobufCBuffer *buffer)
 289 {
 290   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 291   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 292 }
 293 MumbleProto__ChannelRemove *
 294        mumble_proto__channel_remove__unpack
 295                      (ProtobufCAllocator  *allocator,
 296                       size_t               len,
 297                       const uint8_t       *data)
 298 {
 299   return (MumbleProto__ChannelRemove *)
 300      protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
 301                                 allocator, len, data);
 302 }
 303 void   mumble_proto__channel_remove__free_unpacked
 304                      (MumbleProto__ChannelRemove *message,
 305                       ProtobufCAllocator *allocator)
 306 {
 307   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 308   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 309 }
 310 void   mumble_proto__channel_state__init
 311                      (MumbleProto__ChannelState         *message)
 312 {
 313   static MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
 314   *message = init_value;
 315 }
 316 size_t mumble_proto__channel_state__get_packed_size
 317                      (const MumbleProto__ChannelState *message)
 318 {
 319   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 320   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 321 }
 322 size_t mumble_proto__channel_state__pack
 323                      (const MumbleProto__ChannelState *message,
 324                       uint8_t       *out)
 325 {
 326   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 327   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 328 }
 329 size_t mumble_proto__channel_state__pack_to_buffer
 330                      (const MumbleProto__ChannelState *message,
 331                       ProtobufCBuffer *buffer)
 332 {
 333   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 334   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 335 }
 336 MumbleProto__ChannelState *
 337        mumble_proto__channel_state__unpack
 338                      (ProtobufCAllocator  *allocator,
 339                       size_t               len,
 340                       const uint8_t       *data)
 341 {
 342   return (MumbleProto__ChannelState *)
 343      protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
 344                                 allocator, len, data);
 345 }
 346 void   mumble_proto__channel_state__free_unpacked
 347                      (MumbleProto__ChannelState *message,
 348                       ProtobufCAllocator *allocator)
 349 {
 350   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 351   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 352 }
 353 void   mumble_proto__user_remove__init
 354                      (MumbleProto__UserRemove         *message)
 355 {
 356   static MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
 357   *message = init_value;
 358 }
 359 size_t mumble_proto__user_remove__get_packed_size
 360                      (const MumbleProto__UserRemove *message)
 361 {
 362   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 363   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 364 }
 365 size_t mumble_proto__user_remove__pack
 366                      (const MumbleProto__UserRemove *message,
 367                       uint8_t       *out)
 368 {
 369   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 370   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 371 }
 372 size_t mumble_proto__user_remove__pack_to_buffer
 373                      (const MumbleProto__UserRemove *message,
 374                       ProtobufCBuffer *buffer)
 375 {
 376   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 377   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 378 }
 379 MumbleProto__UserRemove *
 380        mumble_proto__user_remove__unpack
 381                      (ProtobufCAllocator  *allocator,
 382                       size_t               len,
 383                       const uint8_t       *data)
 384 {
 385   return (MumbleProto__UserRemove *)
 386      protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
 387                                 allocator, len, data);
 388 }
 389 void   mumble_proto__user_remove__free_unpacked
 390                      (MumbleProto__UserRemove *message,
 391                       ProtobufCAllocator *allocator)
 392 {
 393   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 394   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 395 }
 396 void   mumble_proto__user_state__init
 397                      (MumbleProto__UserState         *message)
 398 {
 399   static MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
 400   *message = init_value;
 401 }
 402 size_t mumble_proto__user_state__get_packed_size
 403                      (const MumbleProto__UserState *message)
 404 {
 405   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 406   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 407 }
 408 size_t mumble_proto__user_state__pack
 409                      (const MumbleProto__UserState *message,
 410                       uint8_t       *out)
 411 {
 412   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 413   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 414 }
 415 size_t mumble_proto__user_state__pack_to_buffer
 416                      (const MumbleProto__UserState *message,
 417                       ProtobufCBuffer *buffer)
 418 {
 419   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 420   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 421 }
 422 MumbleProto__UserState *
 423        mumble_proto__user_state__unpack
 424                      (ProtobufCAllocator  *allocator,
 425                       size_t               len,
 426                       const uint8_t       *data)
 427 {
 428   return (MumbleProto__UserState *)
 429      protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
 430                                 allocator, len, data);
 431 }
 432 void   mumble_proto__user_state__free_unpacked
 433                      (MumbleProto__UserState *message,
 434                       ProtobufCAllocator *allocator)
 435 {
 436   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 437   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 438 }
 439 void   mumble_proto__ban_list__ban_entry__init
 440                      (MumbleProto__BanList__BanEntry         *message)
 441 {
 442   static MumbleProto__BanList__BanEntry init_value = MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT;
 443   *message = init_value;
 444 }
 445 void   mumble_proto__ban_list__init
 446                      (MumbleProto__BanList         *message)
 447 {
 448   static MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
 449   *message = init_value;
 450 }
 451 size_t mumble_proto__ban_list__get_packed_size
 452                      (const MumbleProto__BanList *message)
 453 {
 454   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 455   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 456 }
 457 size_t mumble_proto__ban_list__pack
 458                      (const MumbleProto__BanList *message,
 459                       uint8_t       *out)
 460 {
 461   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 462   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 463 }
 464 size_t mumble_proto__ban_list__pack_to_buffer
 465                      (const MumbleProto__BanList *message,
 466                       ProtobufCBuffer *buffer)
 467 {
 468   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 469   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 470 }
 471 MumbleProto__BanList *
 472        mumble_proto__ban_list__unpack
 473                      (ProtobufCAllocator  *allocator,
 474                       size_t               len,
 475                       const uint8_t       *data)
 476 {
 477   return (MumbleProto__BanList *)
 478      protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
 479                                 allocator, len, data);
 480 }
 481 void   mumble_proto__ban_list__free_unpacked
 482                      (MumbleProto__BanList *message,
 483                       ProtobufCAllocator *allocator)
 484 {
 485   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 486   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 487 }
 488 void   mumble_proto__text_message__init
 489                      (MumbleProto__TextMessage         *message)
 490 {
 491   static MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
 492   *message = init_value;
 493 }
 494 size_t mumble_proto__text_message__get_packed_size
 495                      (const MumbleProto__TextMessage *message)
 496 {
 497   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 498   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 499 }
 500 size_t mumble_proto__text_message__pack
 501                      (const MumbleProto__TextMessage *message,
 502                       uint8_t       *out)
 503 {
 504   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 505   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 506 }
 507 size_t mumble_proto__text_message__pack_to_buffer
 508                      (const MumbleProto__TextMessage *message,
 509                       ProtobufCBuffer *buffer)
 510 {
 511   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 512   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 513 }
 514 MumbleProto__TextMessage *
 515        mumble_proto__text_message__unpack
 516                      (ProtobufCAllocator  *allocator,
 517                       size_t               len,
 518                       const uint8_t       *data)
 519 {
 520   return (MumbleProto__TextMessage *)
 521      protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
 522                                 allocator, len, data);
 523 }
 524 void   mumble_proto__text_message__free_unpacked
 525                      (MumbleProto__TextMessage *message,
 526                       ProtobufCAllocator *allocator)
 527 {
 528   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 529   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 530 }
 531 void   mumble_proto__permission_denied__init
 532                      (MumbleProto__PermissionDenied         *message)
 533 {
 534   static MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
 535   *message = init_value;
 536 }
 537 size_t mumble_proto__permission_denied__get_packed_size
 538                      (const MumbleProto__PermissionDenied *message)
 539 {
 540   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 541   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 542 }
 543 size_t mumble_proto__permission_denied__pack
 544                      (const MumbleProto__PermissionDenied *message,
 545                       uint8_t       *out)
 546 {
 547   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 548   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 549 }
 550 size_t mumble_proto__permission_denied__pack_to_buffer
 551                      (const MumbleProto__PermissionDenied *message,
 552                       ProtobufCBuffer *buffer)
 553 {
 554   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 555   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 556 }
 557 MumbleProto__PermissionDenied *
 558        mumble_proto__permission_denied__unpack
 559                      (ProtobufCAllocator  *allocator,
 560                       size_t               len,
 561                       const uint8_t       *data)
 562 {
 563   return (MumbleProto__PermissionDenied *)
 564      protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
 565                                 allocator, len, data);
 566 }
 567 void   mumble_proto__permission_denied__free_unpacked
 568                      (MumbleProto__PermissionDenied *message,
 569                       ProtobufCAllocator *allocator)
 570 {
 571   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 572   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 573 }
 574 void   mumble_proto__acl__chan_group__init
 575                      (MumbleProto__ACL__ChanGroup         *message)
 576 {
 577   static MumbleProto__ACL__ChanGroup init_value = MUMBLE_PROTO__ACL__CHAN_GROUP__INIT;
 578   *message = init_value;
 579 }
 580 void   mumble_proto__acl__chan_acl__init
 581                      (MumbleProto__ACL__ChanACL         *message)
 582 {
 583   static MumbleProto__ACL__ChanACL init_value = MUMBLE_PROTO__ACL__CHAN_ACL__INIT;
 584   *message = init_value;
 585 }
 586 void   mumble_proto__acl__init
 587                      (MumbleProto__ACL         *message)
 588 {
 589   static MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
 590   *message = init_value;
 591 }
 592 size_t mumble_proto__acl__get_packed_size
 593                      (const MumbleProto__ACL *message)
 594 {
 595   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 596   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 597 }
 598 size_t mumble_proto__acl__pack
 599                      (const MumbleProto__ACL *message,
 600                       uint8_t       *out)
 601 {
 602   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 603   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 604 }
 605 size_t mumble_proto__acl__pack_to_buffer
 606                      (const MumbleProto__ACL *message,
 607                       ProtobufCBuffer *buffer)
 608 {
 609   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 610   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 611 }
 612 MumbleProto__ACL *
 613        mumble_proto__acl__unpack
 614                      (ProtobufCAllocator  *allocator,
 615                       size_t               len,
 616                       const uint8_t       *data)
 617 {
 618   return (MumbleProto__ACL *)
 619      protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
 620                                 allocator, len, data);
 621 }
 622 void   mumble_proto__acl__free_unpacked
 623                      (MumbleProto__ACL *message,
 624                       ProtobufCAllocator *allocator)
 625 {
 626   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 627   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 628 }
 629 void   mumble_proto__query_users__init
 630                      (MumbleProto__QueryUsers         *message)
 631 {
 632   static MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
 633   *message = init_value;
 634 }
 635 size_t mumble_proto__query_users__get_packed_size
 636                      (const MumbleProto__QueryUsers *message)
 637 {
 638   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 639   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 640 }
 641 size_t mumble_proto__query_users__pack
 642                      (const MumbleProto__QueryUsers *message,
 643                       uint8_t       *out)
 644 {
 645   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 646   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 647 }
 648 size_t mumble_proto__query_users__pack_to_buffer
 649                      (const MumbleProto__QueryUsers *message,
 650                       ProtobufCBuffer *buffer)
 651 {
 652   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 653   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 654 }
 655 MumbleProto__QueryUsers *
 656        mumble_proto__query_users__unpack
 657                      (ProtobufCAllocator  *allocator,
 658                       size_t               len,
 659                       const uint8_t       *data)
 660 {
 661   return (MumbleProto__QueryUsers *)
 662      protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
 663                                 allocator, len, data);
 664 }
 665 void   mumble_proto__query_users__free_unpacked
 666                      (MumbleProto__QueryUsers *message,
 667                       ProtobufCAllocator *allocator)
 668 {
 669   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 670   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 671 }
 672 void   mumble_proto__crypt_setup__init
 673                      (MumbleProto__CryptSetup         *message)
 674 {
 675   static MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
 676   *message = init_value;
 677 }
 678 size_t mumble_proto__crypt_setup__get_packed_size
 679                      (const MumbleProto__CryptSetup *message)
 680 {
 681   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 682   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 683 }
 684 size_t mumble_proto__crypt_setup__pack
 685                      (const MumbleProto__CryptSetup *message,
 686                       uint8_t       *out)
 687 {
 688   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 689   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 690 }
 691 size_t mumble_proto__crypt_setup__pack_to_buffer
 692                      (const MumbleProto__CryptSetup *message,
 693                       ProtobufCBuffer *buffer)
 694 {
 695   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 696   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 697 }
 698 MumbleProto__CryptSetup *
 699        mumble_proto__crypt_setup__unpack
 700                      (ProtobufCAllocator  *allocator,
 701                       size_t               len,
 702                       const uint8_t       *data)
 703 {
 704   return (MumbleProto__CryptSetup *)
 705      protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
 706                                 allocator, len, data);
 707 }
 708 void   mumble_proto__crypt_setup__free_unpacked
 709                      (MumbleProto__CryptSetup *message,
 710                       ProtobufCAllocator *allocator)
 711 {
 712   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 713   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 714 }
 715 void   mumble_proto__context_action_add__init
 716                      (MumbleProto__ContextActionAdd         *message)
 717 {
 718   static MumbleProto__ContextActionAdd init_value = MUMBLE_PROTO__CONTEXT_ACTION_ADD__INIT;
 719   *message = init_value;
 720 }
 721 size_t mumble_proto__context_action_add__get_packed_size
 722                      (const MumbleProto__ContextActionAdd *message)
 723 {
 724   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 725   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 726 }
 727 size_t mumble_proto__context_action_add__pack
 728                      (const MumbleProto__ContextActionAdd *message,
 729                       uint8_t       *out)
 730 {
 731   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 732   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 733 }
 734 size_t mumble_proto__context_action_add__pack_to_buffer
 735                      (const MumbleProto__ContextActionAdd *message,
 736                       ProtobufCBuffer *buffer)
 737 {
 738   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 739   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 740 }
 741 MumbleProto__ContextActionAdd *
 742        mumble_proto__context_action_add__unpack
 743                      (ProtobufCAllocator  *allocator,
 744                       size_t               len,
 745                       const uint8_t       *data)
 746 {
 747   return (MumbleProto__ContextActionAdd *)
 748      protobuf_c_message_unpack (&mumble_proto__context_action_add__descriptor,
 749                                 allocator, len, data);
 750 }
 751 void   mumble_proto__context_action_add__free_unpacked
 752                      (MumbleProto__ContextActionAdd *message,
 753                       ProtobufCAllocator *allocator)
 754 {
 755   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 756   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 757 }
 758 void   mumble_proto__context_action__init
 759                      (MumbleProto__ContextAction         *message)
 760 {
 761   static MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
 762   *message = init_value;
 763 }
 764 size_t mumble_proto__context_action__get_packed_size
 765                      (const MumbleProto__ContextAction *message)
 766 {
 767   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 768   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 769 }
 770 size_t mumble_proto__context_action__pack
 771                      (const MumbleProto__ContextAction *message,
 772                       uint8_t       *out)
 773 {
 774   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 775   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 776 }
 777 size_t mumble_proto__context_action__pack_to_buffer
 778                      (const MumbleProto__ContextAction *message,
 779                       ProtobufCBuffer *buffer)
 780 {
 781   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 782   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 783 }
 784 MumbleProto__ContextAction *
 785        mumble_proto__context_action__unpack
 786                      (ProtobufCAllocator  *allocator,
 787                       size_t               len,
 788                       const uint8_t       *data)
 789 {
 790   return (MumbleProto__ContextAction *)
 791      protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
 792                                 allocator, len, data);
 793 }
 794 void   mumble_proto__context_action__free_unpacked
 795                      (MumbleProto__ContextAction *message,
 796                       ProtobufCAllocator *allocator)
 797 {
 798   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 799   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 800 }
 801 void   mumble_proto__user_list__user__init
 802                      (MumbleProto__UserList__User         *message)
 803 {
 804   static MumbleProto__UserList__User init_value = MUMBLE_PROTO__USER_LIST__USER__INIT;
 805   *message = init_value;
 806 }
 807 void   mumble_proto__user_list__init
 808                      (MumbleProto__UserList         *message)
 809 {
 810   static MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
 811   *message = init_value;
 812 }
 813 size_t mumble_proto__user_list__get_packed_size
 814                      (const MumbleProto__UserList *message)
 815 {
 816   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 817   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 818 }
 819 size_t mumble_proto__user_list__pack
 820                      (const MumbleProto__UserList *message,
 821                       uint8_t       *out)
 822 {
 823   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 824   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 825 }
 826 size_t mumble_proto__user_list__pack_to_buffer
 827                      (const MumbleProto__UserList *message,
 828                       ProtobufCBuffer *buffer)
 829 {
 830   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 831   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 832 }
 833 MumbleProto__UserList *
 834        mumble_proto__user_list__unpack
 835                      (ProtobufCAllocator  *allocator,
 836                       size_t               len,
 837                       const uint8_t       *data)
 838 {
 839   return (MumbleProto__UserList *)
 840      protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
 841                                 allocator, len, data);
 842 }
 843 void   mumble_proto__user_list__free_unpacked
 844                      (MumbleProto__UserList *message,
 845                       ProtobufCAllocator *allocator)
 846 {
 847   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 848   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 849 }
 850 void   mumble_proto__voice_target__target__init
 851                      (MumbleProto__VoiceTarget__Target         *message)
 852 {
 853   static MumbleProto__VoiceTarget__Target init_value = MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT;
 854   *message = init_value;
 855 }
 856 void   mumble_proto__voice_target__init
 857                      (MumbleProto__VoiceTarget         *message)
 858 {
 859   static MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
 860   *message = init_value;
 861 }
 862 size_t mumble_proto__voice_target__get_packed_size
 863                      (const MumbleProto__VoiceTarget *message)
 864 {
 865   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 866   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 867 }
 868 size_t mumble_proto__voice_target__pack
 869                      (const MumbleProto__VoiceTarget *message,
 870                       uint8_t       *out)
 871 {
 872   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 873   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 874 }
 875 size_t mumble_proto__voice_target__pack_to_buffer
 876                      (const MumbleProto__VoiceTarget *message,
 877                       ProtobufCBuffer *buffer)
 878 {
 879   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 880   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 881 }
 882 MumbleProto__VoiceTarget *
 883        mumble_proto__voice_target__unpack
 884                      (ProtobufCAllocator  *allocator,
 885                       size_t               len,
 886                       const uint8_t       *data)
 887 {
 888   return (MumbleProto__VoiceTarget *)
 889      protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
 890                                 allocator, len, data);
 891 }
 892 void   mumble_proto__voice_target__free_unpacked
 893                      (MumbleProto__VoiceTarget *message,
 894                       ProtobufCAllocator *allocator)
 895 {
 896   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 897   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 898 }
 899 void   mumble_proto__permission_query__init
 900                      (MumbleProto__PermissionQuery         *message)
 901 {
 902   static MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
 903   *message = init_value;
 904 }
 905 size_t mumble_proto__permission_query__get_packed_size
 906                      (const MumbleProto__PermissionQuery *message)
 907 {
 908   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 909   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 910 }
 911 size_t mumble_proto__permission_query__pack
 912                      (const MumbleProto__PermissionQuery *message,
 913                       uint8_t       *out)
 914 {
 915   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 916   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 917 }
 918 size_t mumble_proto__permission_query__pack_to_buffer
 919                      (const MumbleProto__PermissionQuery *message,
 920                       ProtobufCBuffer *buffer)
 921 {
 922   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 923   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 924 }
 925 MumbleProto__PermissionQuery *
 926        mumble_proto__permission_query__unpack
 927                      (ProtobufCAllocator  *allocator,
 928                       size_t               len,
 929                       const uint8_t       *data)
 930 {
 931   return (MumbleProto__PermissionQuery *)
 932      protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
 933                                 allocator, len, data);
 934 }
 935 void   mumble_proto__permission_query__free_unpacked
 936                      (MumbleProto__PermissionQuery *message,
 937                       ProtobufCAllocator *allocator)
 938 {
 939   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 940   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 941 }
 942 void   mumble_proto__codec_version__init
 943                      (MumbleProto__CodecVersion         *message)
 944 {
 945   static MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
 946   *message = init_value;
 947 }
 948 size_t mumble_proto__codec_version__get_packed_size
 949                      (const MumbleProto__CodecVersion *message)
 950 {
 951   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 952   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 953 }
 954 size_t mumble_proto__codec_version__pack
 955                      (const MumbleProto__CodecVersion *message,
 956                       uint8_t       *out)
 957 {
 958   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 959   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 960 }
 961 size_t mumble_proto__codec_version__pack_to_buffer
 962                      (const MumbleProto__CodecVersion *message,
 963                       ProtobufCBuffer *buffer)
 964 {
 965   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 966   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 967 }
 968 MumbleProto__CodecVersion *
 969        mumble_proto__codec_version__unpack
 970                      (ProtobufCAllocator  *allocator,
 971                       size_t               len,
 972                       const uint8_t       *data)
 973 {
 974   return (MumbleProto__CodecVersion *)
 975      protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
 976                                 allocator, len, data);
 977 }
 978 void   mumble_proto__codec_version__free_unpacked
 979                      (MumbleProto__CodecVersion *message,
 980                       ProtobufCAllocator *allocator)
 981 {
 982   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 983   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 984 }
 985 static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
 986 {
 987   {
 988     "version",
 989     1,
 990     PROTOBUF_C_LABEL_OPTIONAL,
 991     PROTOBUF_C_TYPE_UINT32,
 992     PROTOBUF_C_OFFSETOF(MumbleProto__Version, has_version),
 993     PROTOBUF_C_OFFSETOF(MumbleProto__Version, version),
 994     NULL,
 995     NULL,
 996     0,            /* packed */
 997     0,NULL,NULL    /* reserved1,reserved2, etc */
 998   },
 999   {
1000     "release",
1001     2,
1002     PROTOBUF_C_LABEL_OPTIONAL,
1003     PROTOBUF_C_TYPE_STRING,
1004     0,   /* quantifier_offset */
1005     PROTOBUF_C_OFFSETOF(MumbleProto__Version, release),
1006     NULL,
1007     NULL,
1008     0,            /* packed */
1009     0,NULL,NULL    /* reserved1,reserved2, etc */
1010   },
1011   {
1012     "os",
1013     3,
1014     PROTOBUF_C_LABEL_OPTIONAL,
1015     PROTOBUF_C_TYPE_STRING,
1016     0,   /* quantifier_offset */
1017     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os),
1018     NULL,
1019     NULL,
1020     0,            /* packed */
1021     0,NULL,NULL    /* reserved1,reserved2, etc */
1022   },
1023   {
1024     "os_version",
1025     4,
1026     PROTOBUF_C_LABEL_OPTIONAL,
1027     PROTOBUF_C_TYPE_STRING,
1028     0,   /* quantifier_offset */
1029     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os_version),
1030     NULL,
1031     NULL,
1032     0,            /* packed */
1033     0,NULL,NULL    /* reserved1,reserved2, etc */
1034   },
1035 };
1036 static const unsigned mumble_proto__version__field_indices_by_name[] = {
1037   2,   /* field[2] = os */
1038   3,   /* field[3] = os_version */
1039   1,   /* field[1] = release */
1040   0,   /* field[0] = version */
1041 };
1042 static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
1043 {
1044   { 1, 0 },
1045   { 0, 4 }
1046 };
1047 const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
1048 {
1049   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1050   "MumbleProto.Version",
1051   "Version",
1052   "MumbleProto__Version",
1053   "MumbleProto",
1054   sizeof(MumbleProto__Version),
1055   4,
1056   mumble_proto__version__field_descriptors,
1057   mumble_proto__version__field_indices_by_name,
1058   1,  mumble_proto__version__number_ranges,
1059   (ProtobufCMessageInit) mumble_proto__version__init,
1060   NULL,NULL,NULL    /* reserved[123] */
1061 };
1062 static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
1063 {
1064   {
1065     "packet",
1066     1,
1067     PROTOBUF_C_LABEL_REQUIRED,
1068     PROTOBUF_C_TYPE_BYTES,
1069     0,   /* quantifier_offset */
1070     PROTOBUF_C_OFFSETOF(MumbleProto__UDPTunnel, packet),
1071     NULL,
1072     NULL,
1073     0,            /* packed */
1074     0,NULL,NULL    /* reserved1,reserved2, etc */
1075   },
1076 };
1077 static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
1078   0,   /* field[0] = packet */
1079 };
1080 static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
1081 {
1082   { 1, 0 },
1083   { 0, 1 }
1084 };
1085 const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
1086 {
1087   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1088   "MumbleProto.UDPTunnel",
1089   "UDPTunnel",
1090   "MumbleProto__UDPTunnel",
1091   "MumbleProto",
1092   sizeof(MumbleProto__UDPTunnel),
1093   1,
1094   mumble_proto__udptunnel__field_descriptors,
1095   mumble_proto__udptunnel__field_indices_by_name,
1096   1,  mumble_proto__udptunnel__number_ranges,
1097   (ProtobufCMessageInit) mumble_proto__udptunnel__init,
1098   NULL,NULL,NULL    /* reserved[123] */
1099 };
1100 static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[4] =
1101 {
1102   {
1103     "username",
1104     1,
1105     PROTOBUF_C_LABEL_OPTIONAL,
1106     PROTOBUF_C_TYPE_STRING,
1107     0,   /* quantifier_offset */
1108     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, username),
1109     NULL,
1110     NULL,
1111     0,            /* packed */
1112     0,NULL,NULL    /* reserved1,reserved2, etc */
1113   },
1114   {
1115     "password",
1116     2,
1117     PROTOBUF_C_LABEL_OPTIONAL,
1118     PROTOBUF_C_TYPE_STRING,
1119     0,   /* quantifier_offset */
1120     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, password),
1121     NULL,
1122     NULL,
1123     0,            /* packed */
1124     0,NULL,NULL    /* reserved1,reserved2, etc */
1125   },
1126   {
1127     "tokens",
1128     3,
1129     PROTOBUF_C_LABEL_REPEATED,
1130     PROTOBUF_C_TYPE_STRING,
1131     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_tokens),
1132     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, tokens),
1133     NULL,
1134     NULL,
1135     0,            /* packed */
1136     0,NULL,NULL    /* reserved1,reserved2, etc */
1137   },
1138   {
1139     "celt_versions",
1140     4,
1141     PROTOBUF_C_LABEL_REPEATED,
1142     PROTOBUF_C_TYPE_INT32,
1143     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_celt_versions),
1144     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, celt_versions),
1145     NULL,
1146     NULL,
1147     0,            /* packed */
1148     0,NULL,NULL    /* reserved1,reserved2, etc */
1149   },
1150 };
1151 static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
1152   3,   /* field[3] = celt_versions */
1153   1,   /* field[1] = password */
1154   2,   /* field[2] = tokens */
1155   0,   /* field[0] = username */
1156 };
1157 static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
1158 {
1159   { 1, 0 },
1160   { 0, 4 }
1161 };
1162 const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
1163 {
1164   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1165   "MumbleProto.Authenticate",
1166   "Authenticate",
1167   "MumbleProto__Authenticate",
1168   "MumbleProto",
1169   sizeof(MumbleProto__Authenticate),
1170   4,
1171   mumble_proto__authenticate__field_descriptors,
1172   mumble_proto__authenticate__field_indices_by_name,
1173   1,  mumble_proto__authenticate__number_ranges,
1174   (ProtobufCMessageInit) mumble_proto__authenticate__init,
1175   NULL,NULL,NULL    /* reserved[123] */
1176 };
1177 static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
1178 {
1179   {
1180     "timestamp",
1181     1,
1182     PROTOBUF_C_LABEL_OPTIONAL,
1183     PROTOBUF_C_TYPE_UINT64,
1184     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_timestamp),
1185     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, timestamp),
1186     NULL,
1187     NULL,
1188     0,            /* packed */
1189     0,NULL,NULL    /* reserved1,reserved2, etc */
1190   },
1191   {
1192     "good",
1193     2,
1194     PROTOBUF_C_LABEL_OPTIONAL,
1195     PROTOBUF_C_TYPE_UINT32,
1196     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_good),
1197     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, good),
1198     NULL,
1199     NULL,
1200     0,            /* packed */
1201     0,NULL,NULL    /* reserved1,reserved2, etc */
1202   },
1203   {
1204     "late",
1205     3,
1206     PROTOBUF_C_LABEL_OPTIONAL,
1207     PROTOBUF_C_TYPE_UINT32,
1208     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_late),
1209     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, late),
1210     NULL,
1211     NULL,
1212     0,            /* packed */
1213     0,NULL,NULL    /* reserved1,reserved2, etc */
1214   },
1215   {
1216     "lost",
1217     4,
1218     PROTOBUF_C_LABEL_OPTIONAL,
1219     PROTOBUF_C_TYPE_UINT32,
1220     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_lost),
1221     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, lost),
1222     NULL,
1223     NULL,
1224     0,            /* packed */
1225     0,NULL,NULL    /* reserved1,reserved2, etc */
1226   },
1227   {
1228     "resync",
1229     5,
1230     PROTOBUF_C_LABEL_OPTIONAL,
1231     PROTOBUF_C_TYPE_UINT32,
1232     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_resync),
1233     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, resync),
1234     NULL,
1235     NULL,
1236     0,            /* packed */
1237     0,NULL,NULL    /* reserved1,reserved2, etc */
1238   },
1239   {
1240     "udp_packets",
1241     6,
1242     PROTOBUF_C_LABEL_OPTIONAL,
1243     PROTOBUF_C_TYPE_UINT32,
1244     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_packets),
1245     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_packets),
1246     NULL,
1247     NULL,
1248     0,            /* packed */
1249     0,NULL,NULL    /* reserved1,reserved2, etc */
1250   },
1251   {
1252     "tcp_packets",
1253     7,
1254     PROTOBUF_C_LABEL_OPTIONAL,
1255     PROTOBUF_C_TYPE_UINT32,
1256     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_packets),
1257     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_packets),
1258     NULL,
1259     NULL,
1260     0,            /* packed */
1261     0,NULL,NULL    /* reserved1,reserved2, etc */
1262   },
1263   {
1264     "udp_ping_avg",
1265     8,
1266     PROTOBUF_C_LABEL_OPTIONAL,
1267     PROTOBUF_C_TYPE_FLOAT,
1268     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_avg),
1269     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_avg),
1270     NULL,
1271     NULL,
1272     0,            /* packed */
1273     0,NULL,NULL    /* reserved1,reserved2, etc */
1274   },
1275   {
1276     "udp_ping_var",
1277     9,
1278     PROTOBUF_C_LABEL_OPTIONAL,
1279     PROTOBUF_C_TYPE_FLOAT,
1280     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_var),
1281     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_var),
1282     NULL,
1283     NULL,
1284     0,            /* packed */
1285     0,NULL,NULL    /* reserved1,reserved2, etc */
1286   },
1287   {
1288     "tcp_ping_avg",
1289     10,
1290     PROTOBUF_C_LABEL_OPTIONAL,
1291     PROTOBUF_C_TYPE_FLOAT,
1292     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_avg),
1293     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_avg),
1294     NULL,
1295     NULL,
1296     0,            /* packed */
1297     0,NULL,NULL    /* reserved1,reserved2, etc */
1298   },
1299   {
1300     "tcp_ping_var",
1301     11,
1302     PROTOBUF_C_LABEL_OPTIONAL,
1303     PROTOBUF_C_TYPE_FLOAT,
1304     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_var),
1305     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_var),
1306     NULL,
1307     NULL,
1308     0,            /* packed */
1309     0,NULL,NULL    /* reserved1,reserved2, etc */
1310   },
1311 };
1312 static const unsigned mumble_proto__ping__field_indices_by_name[] = {
1313   1,   /* field[1] = good */
1314   2,   /* field[2] = late */
1315   3,   /* field[3] = lost */
1316   4,   /* field[4] = resync */
1317   6,   /* field[6] = tcp_packets */
1318   9,   /* field[9] = tcp_ping_avg */
1319   10,   /* field[10] = tcp_ping_var */
1320   0,   /* field[0] = timestamp */
1321   5,   /* field[5] = udp_packets */
1322   7,   /* field[7] = udp_ping_avg */
1323   8,   /* field[8] = udp_ping_var */
1324 };
1325 static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
1326 {
1327   { 1, 0 },
1328   { 0, 11 }
1329 };
1330 const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
1331 {
1332   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1333   "MumbleProto.Ping",
1334   "Ping",
1335   "MumbleProto__Ping",
1336   "MumbleProto",
1337   sizeof(MumbleProto__Ping),
1338   11,
1339   mumble_proto__ping__field_descriptors,
1340   mumble_proto__ping__field_indices_by_name,
1341   1,  mumble_proto__ping__number_ranges,
1342   (ProtobufCMessageInit) mumble_proto__ping__init,
1343   NULL,NULL,NULL    /* reserved[123] */
1344 };
1345 const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
1346 {
1347   { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NONE", 0 },
1348   { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGVERSION", 1 },
1349   { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__INVALIDUSERNAME", 2 },
1350   { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGUSERPW", 3 },
1351   { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGSERVERPW", 4 },
1352   { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__USERNAMEINUSE", 5 },
1353   { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__SERVERFULL", 6 },
1354   { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NOCERTIFICATE", 7 },
1355 };
1356 static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
1357 {0, 0},{0, 8}
1358 };
1359 const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
1360 {
1361   { "InvalidUsername", 2 },
1362   { "NoCertificate", 7 },
1363   { "None", 0 },
1364   { "ServerFull", 6 },
1365   { "UsernameInUse", 5 },
1366   { "WrongServerPW", 4 },
1367   { "WrongUserPW", 3 },
1368   { "WrongVersion", 1 },
1369 };
1370 const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
1371 {
1372   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
1373   "MumbleProto.Reject.RejectType",
1374   "RejectType",
1375   "MumbleProto__Reject__RejectType",
1376   "MumbleProto",
1377   8,
1378   mumble_proto__reject__reject_type__enum_values_by_number,
1379   8,
1380   mumble_proto__reject__reject_type__enum_values_by_name,
1381   1,
1382   mumble_proto__reject__reject_type__value_ranges,
1383   NULL,NULL,NULL,NULL   /* reserved[1234] */
1384 };
1385 static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
1386 {
1387   {
1388     "type",
1389     1,
1390     PROTOBUF_C_LABEL_OPTIONAL,
1391     PROTOBUF_C_TYPE_ENUM,
1392     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, has_type),
1393     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, type),
1394     &mumble_proto__reject__reject_type__descriptor,
1395     NULL,
1396     0,            /* packed */
1397     0,NULL,NULL    /* reserved1,reserved2, etc */
1398   },
1399   {
1400     "reason",
1401     2,
1402     PROTOBUF_C_LABEL_OPTIONAL,
1403     PROTOBUF_C_TYPE_STRING,
1404     0,   /* quantifier_offset */
1405     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, reason),
1406     NULL,
1407     NULL,
1408     0,            /* packed */
1409     0,NULL,NULL    /* reserved1,reserved2, etc */
1410   },
1411 };
1412 static const unsigned mumble_proto__reject__field_indices_by_name[] = {
1413   1,   /* field[1] = reason */
1414   0,   /* field[0] = type */
1415 };
1416 static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
1417 {
1418   { 1, 0 },
1419   { 0, 2 }
1420 };
1421 const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
1422 {
1423   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1424   "MumbleProto.Reject",
1425   "Reject",
1426   "MumbleProto__Reject",
1427   "MumbleProto",
1428   sizeof(MumbleProto__Reject),
1429   2,
1430   mumble_proto__reject__field_descriptors,
1431   mumble_proto__reject__field_indices_by_name,
1432   1,  mumble_proto__reject__number_ranges,
1433   (ProtobufCMessageInit) mumble_proto__reject__init,
1434   NULL,NULL,NULL    /* reserved[123] */
1435 };
1436 static const protobuf_c_boolean mumble_proto__server_sync__allow_html__default_value = 1;
1437 static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[5] =
1438 {
1439   {
1440     "session",
1441     1,
1442     PROTOBUF_C_LABEL_OPTIONAL,
1443     PROTOBUF_C_TYPE_UINT32,
1444     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_session),
1445     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, session),
1446     NULL,
1447     NULL,
1448     0,            /* packed */
1449     0,NULL,NULL    /* reserved1,reserved2, etc */
1450   },
1451   {
1452     "max_bandwidth",
1453     2,
1454     PROTOBUF_C_LABEL_OPTIONAL,
1455     PROTOBUF_C_TYPE_UINT32,
1456     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_max_bandwidth),
1457     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, max_bandwidth),
1458     NULL,
1459     NULL,
1460     0,            /* packed */
1461     0,NULL,NULL    /* reserved1,reserved2, etc */
1462   },
1463   {
1464     "welcome_text",
1465     3,
1466     PROTOBUF_C_LABEL_OPTIONAL,
1467     PROTOBUF_C_TYPE_STRING,
1468     0,   /* quantifier_offset */
1469     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, welcome_text),
1470     NULL,
1471     NULL,
1472     0,            /* packed */
1473     0,NULL,NULL    /* reserved1,reserved2, etc */
1474   },
1475   {
1476     "permissions",
1477     4,
1478     PROTOBUF_C_LABEL_OPTIONAL,
1479     PROTOBUF_C_TYPE_UINT64,
1480     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_permissions),
1481     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, permissions),
1482     NULL,
1483     NULL,
1484     0,            /* packed */
1485     0,NULL,NULL    /* reserved1,reserved2, etc */
1486   },
1487   {
1488     "allow_html",
1489     5,
1490     PROTOBUF_C_LABEL_OPTIONAL,
1491     PROTOBUF_C_TYPE_BOOL,
1492     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_allow_html),
1493     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, allow_html),
1494     NULL,
1495     &mumble_proto__server_sync__allow_html__default_value,
1496     0,            /* packed */
1497     0,NULL,NULL    /* reserved1,reserved2, etc */
1498   },
1499 };
1500 static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
1501   4,   /* field[4] = allow_html */
1502   1,   /* field[1] = max_bandwidth */
1503   3,   /* field[3] = permissions */
1504   0,   /* field[0] = session */
1505   2,   /* field[2] = welcome_text */
1506 };
1507 static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
1508 {
1509   { 1, 0 },
1510   { 0, 5 }
1511 };
1512 const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
1513 {
1514   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1515   "MumbleProto.ServerSync",
1516   "ServerSync",
1517   "MumbleProto__ServerSync",
1518   "MumbleProto",
1519   sizeof(MumbleProto__ServerSync),
1520   5,
1521   mumble_proto__server_sync__field_descriptors,
1522   mumble_proto__server_sync__field_indices_by_name,
1523   1,  mumble_proto__server_sync__number_ranges,
1524   (ProtobufCMessageInit) mumble_proto__server_sync__init,
1525   NULL,NULL,NULL    /* reserved[123] */
1526 };
1527 static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
1528 {
1529   {
1530     "channel_id",
1531     1,
1532     PROTOBUF_C_LABEL_REQUIRED,
1533     PROTOBUF_C_TYPE_UINT32,
1534     0,   /* quantifier_offset */
1535     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelRemove, channel_id),
1536     NULL,
1537     NULL,
1538     0,            /* packed */
1539     0,NULL,NULL    /* reserved1,reserved2, etc */
1540   },
1541 };
1542 static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
1543   0,   /* field[0] = channel_id */
1544 };
1545 static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
1546 {
1547   { 1, 0 },
1548   { 0, 1 }
1549 };
1550 const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
1551 {
1552   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1553   "MumbleProto.ChannelRemove",
1554   "ChannelRemove",
1555   "MumbleProto__ChannelRemove",
1556   "MumbleProto",
1557   sizeof(MumbleProto__ChannelRemove),
1558   1,
1559   mumble_proto__channel_remove__field_descriptors,
1560   mumble_proto__channel_remove__field_indices_by_name,
1561   1,  mumble_proto__channel_remove__number_ranges,
1562   (ProtobufCMessageInit) mumble_proto__channel_remove__init,
1563   NULL,NULL,NULL    /* reserved[123] */
1564 };
1565 static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
1566 static const int32_t mumble_proto__channel_state__position__default_value = 0;
1567 static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[9] =
1568 {
1569   {
1570     "channel_id",
1571     1,
1572     PROTOBUF_C_LABEL_OPTIONAL,
1573     PROTOBUF_C_TYPE_UINT32,
1574     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_channel_id),
1575     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, channel_id),
1576     NULL,
1577     NULL,
1578     0,            /* packed */
1579     0,NULL,NULL    /* reserved1,reserved2, etc */
1580   },
1581   {
1582     "parent",
1583     2,
1584     PROTOBUF_C_LABEL_OPTIONAL,
1585     PROTOBUF_C_TYPE_UINT32,
1586     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_parent),
1587     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, parent),
1588     NULL,
1589     NULL,
1590     0,            /* packed */
1591     0,NULL,NULL    /* reserved1,reserved2, etc */
1592   },
1593   {
1594     "name",
1595     3,
1596     PROTOBUF_C_LABEL_OPTIONAL,
1597     PROTOBUF_C_TYPE_STRING,
1598     0,   /* quantifier_offset */
1599     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, name),
1600     NULL,
1601     NULL,
1602     0,            /* packed */
1603     0,NULL,NULL    /* reserved1,reserved2, etc */
1604   },
1605   {
1606     "links",
1607     4,
1608     PROTOBUF_C_LABEL_REPEATED,
1609     PROTOBUF_C_TYPE_UINT32,
1610     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links),
1611     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links),
1612     NULL,
1613     NULL,
1614     0,            /* packed */
1615     0,NULL,NULL    /* reserved1,reserved2, etc */
1616   },
1617   {
1618     "description",
1619     5,
1620     PROTOBUF_C_LABEL_OPTIONAL,
1621     PROTOBUF_C_TYPE_STRING,
1622     0,   /* quantifier_offset */
1623     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description),
1624     NULL,
1625     NULL,
1626     0,            /* packed */
1627     0,NULL,NULL    /* reserved1,reserved2, etc */
1628   },
1629   {
1630     "links_add",
1631     6,
1632     PROTOBUF_C_LABEL_REPEATED,
1633     PROTOBUF_C_TYPE_UINT32,
1634     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_add),
1635     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_add),
1636     NULL,
1637     NULL,
1638     0,            /* packed */
1639     0,NULL,NULL    /* reserved1,reserved2, etc */
1640   },
1641   {
1642     "links_remove",
1643     7,
1644     PROTOBUF_C_LABEL_REPEATED,
1645     PROTOBUF_C_TYPE_UINT32,
1646     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_remove),
1647     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_remove),
1648     NULL,
1649     NULL,
1650     0,            /* packed */
1651     0,NULL,NULL    /* reserved1,reserved2, etc */
1652   },
1653   {
1654     "temporary",
1655     8,
1656     PROTOBUF_C_LABEL_OPTIONAL,
1657     PROTOBUF_C_TYPE_BOOL,
1658     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_temporary),
1659     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, temporary),
1660     NULL,
1661     &mumble_proto__channel_state__temporary__default_value,
1662     0,            /* packed */
1663     0,NULL,NULL    /* reserved1,reserved2, etc */
1664   },
1665   {
1666     "position",
1667     9,
1668     PROTOBUF_C_LABEL_OPTIONAL,
1669     PROTOBUF_C_TYPE_INT32,
1670     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_position),
1671     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, position),
1672     NULL,
1673     &mumble_proto__channel_state__position__default_value,
1674     0,            /* packed */
1675     0,NULL,NULL    /* reserved1,reserved2, etc */
1676   },
1677 };
1678 static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
1679   0,   /* field[0] = channel_id */
1680   4,   /* field[4] = description */
1681   3,   /* field[3] = links */
1682   5,   /* field[5] = links_add */
1683   6,   /* field[6] = links_remove */
1684   2,   /* field[2] = name */
1685   1,   /* field[1] = parent */
1686   8,   /* field[8] = position */
1687   7,   /* field[7] = temporary */
1688 };
1689 static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
1690 {
1691   { 1, 0 },
1692   { 0, 9 }
1693 };
1694 const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
1695 {
1696   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1697   "MumbleProto.ChannelState",
1698   "ChannelState",
1699   "MumbleProto__ChannelState",
1700   "MumbleProto",
1701   sizeof(MumbleProto__ChannelState),
1702   9,
1703   mumble_proto__channel_state__field_descriptors,
1704   mumble_proto__channel_state__field_indices_by_name,
1705   1,  mumble_proto__channel_state__number_ranges,
1706   (ProtobufCMessageInit) mumble_proto__channel_state__init,
1707   NULL,NULL,NULL    /* reserved[123] */
1708 };
1709 static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
1710 {
1711   {
1712     "session",
1713     1,
1714     PROTOBUF_C_LABEL_REQUIRED,
1715     PROTOBUF_C_TYPE_UINT32,
1716     0,   /* quantifier_offset */
1717     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, session),
1718     NULL,
1719     NULL,
1720     0,            /* packed */
1721     0,NULL,NULL    /* reserved1,reserved2, etc */
1722   },
1723   {
1724     "actor",
1725     2,
1726     PROTOBUF_C_LABEL_OPTIONAL,
1727     PROTOBUF_C_TYPE_UINT32,
1728     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_actor),
1729     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, actor),
1730     NULL,
1731     NULL,
1732     0,            /* packed */
1733     0,NULL,NULL    /* reserved1,reserved2, etc */
1734   },
1735   {
1736     "reason",
1737     3,
1738     PROTOBUF_C_LABEL_OPTIONAL,
1739     PROTOBUF_C_TYPE_STRING,
1740     0,   /* quantifier_offset */
1741     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, reason),
1742     NULL,
1743     NULL,
1744     0,            /* packed */
1745     0,NULL,NULL    /* reserved1,reserved2, etc */
1746   },
1747   {
1748     "ban",
1749     4,
1750     PROTOBUF_C_LABEL_OPTIONAL,
1751     PROTOBUF_C_TYPE_BOOL,
1752     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_ban),
1753     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, ban),
1754     NULL,
1755     NULL,
1756     0,            /* packed */
1757     0,NULL,NULL    /* reserved1,reserved2, etc */
1758   },
1759 };
1760 static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
1761   1,   /* field[1] = actor */
1762   3,   /* field[3] = ban */
1763   2,   /* field[2] = reason */
1764   0,   /* field[0] = session */
1765 };
1766 static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
1767 {
1768   { 1, 0 },
1769   { 0, 4 }
1770 };
1771 const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
1772 {
1773   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1774   "MumbleProto.UserRemove",
1775   "UserRemove",
1776   "MumbleProto__UserRemove",
1777   "MumbleProto",
1778   sizeof(MumbleProto__UserRemove),
1779   4,
1780   mumble_proto__user_remove__field_descriptors,
1781   mumble_proto__user_remove__field_indices_by_name,
1782   1,  mumble_proto__user_remove__number_ranges,
1783   (ProtobufCMessageInit) mumble_proto__user_remove__init,
1784   NULL,NULL,NULL    /* reserved[123] */
1785 };
1786 static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[15] =
1787 {
1788   {
1789     "session",
1790     1,
1791     PROTOBUF_C_LABEL_OPTIONAL,
1792     PROTOBUF_C_TYPE_UINT32,
1793     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_session),
1794     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, session),
1795     NULL,
1796     NULL,
1797     0,            /* packed */
1798     0,NULL,NULL    /* reserved1,reserved2, etc */
1799   },
1800   {
1801     "actor",
1802     2,
1803     PROTOBUF_C_LABEL_OPTIONAL,
1804     PROTOBUF_C_TYPE_UINT32,
1805     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_actor),
1806     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, actor),
1807     NULL,
1808     NULL,
1809     0,            /* packed */
1810     0,NULL,NULL    /* reserved1,reserved2, etc */
1811   },
1812   {
1813     "name",
1814     3,
1815     PROTOBUF_C_LABEL_OPTIONAL,
1816     PROTOBUF_C_TYPE_STRING,
1817     0,   /* quantifier_offset */
1818     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, name),
1819     NULL,
1820     NULL,
1821     0,            /* packed */
1822     0,NULL,NULL    /* reserved1,reserved2, etc */
1823   },
1824   {
1825     "user_id",
1826     4,
1827     PROTOBUF_C_LABEL_OPTIONAL,
1828     PROTOBUF_C_TYPE_UINT32,
1829     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_user_id),
1830     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, user_id),
1831     NULL,
1832     NULL,
1833     0,            /* packed */
1834     0,NULL,NULL    /* reserved1,reserved2, etc */
1835   },
1836   {
1837     "channel_id",
1838     5,
1839     PROTOBUF_C_LABEL_OPTIONAL,
1840     PROTOBUF_C_TYPE_UINT32,
1841     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_channel_id),
1842     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, channel_id),
1843     NULL,
1844     NULL,
1845     0,            /* packed */
1846     0,NULL,NULL    /* reserved1,reserved2, etc */
1847   },
1848   {
1849     "mute",
1850     6,
1851     PROTOBUF_C_LABEL_OPTIONAL,
1852     PROTOBUF_C_TYPE_BOOL,
1853     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_mute),
1854     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, mute),
1855     NULL,
1856     NULL,
1857     0,            /* packed */
1858     0,NULL,NULL    /* reserved1,reserved2, etc */
1859   },
1860   {
1861     "deaf",
1862     7,
1863     PROTOBUF_C_LABEL_OPTIONAL,
1864     PROTOBUF_C_TYPE_BOOL,
1865     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_deaf),
1866     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, deaf),
1867     NULL,
1868     NULL,
1869     0,            /* packed */
1870     0,NULL,NULL    /* reserved1,reserved2, etc */
1871   },
1872   {
1873     "suppress",
1874     8,
1875     PROTOBUF_C_LABEL_OPTIONAL,
1876     PROTOBUF_C_TYPE_BOOL,
1877     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_suppress),
1878     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, suppress),
1879     NULL,
1880     NULL,
1881     0,            /* packed */
1882     0,NULL,NULL    /* reserved1,reserved2, etc */
1883   },
1884   {
1885     "self_mute",
1886     9,
1887     PROTOBUF_C_LABEL_OPTIONAL,
1888     PROTOBUF_C_TYPE_BOOL,
1889     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_mute),
1890     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_mute),
1891     NULL,
1892     NULL,
1893     0,            /* packed */
1894     0,NULL,NULL    /* reserved1,reserved2, etc */
1895   },
1896   {
1897     "self_deaf",
1898     10,
1899     PROTOBUF_C_LABEL_OPTIONAL,
1900     PROTOBUF_C_TYPE_BOOL,
1901     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_deaf),
1902     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_deaf),
1903     NULL,
1904     NULL,
1905     0,            /* packed */
1906     0,NULL,NULL    /* reserved1,reserved2, etc */
1907   },
1908   {
1909     "texture",
1910     11,
1911     PROTOBUF_C_LABEL_OPTIONAL,
1912     PROTOBUF_C_TYPE_BYTES,
1913     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture),
1914     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture),
1915     NULL,
1916     NULL,
1917     0,            /* packed */
1918     0,NULL,NULL    /* reserved1,reserved2, etc */
1919   },
1920   {
1921     "plugin_context",
1922     12,
1923     PROTOBUF_C_LABEL_OPTIONAL,
1924     PROTOBUF_C_TYPE_STRING,
1925     0,   /* quantifier_offset */
1926     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_context),
1927     NULL,
1928     NULL,
1929     0,            /* packed */
1930     0,NULL,NULL    /* reserved1,reserved2, etc */
1931   },
1932   {
1933     "plugin_identity",
1934     13,
1935     PROTOBUF_C_LABEL_OPTIONAL,
1936     PROTOBUF_C_TYPE_STRING,
1937     0,   /* quantifier_offset */
1938     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_identity),
1939     NULL,
1940     NULL,
1941     0,            /* packed */
1942     0,NULL,NULL    /* reserved1,reserved2, etc */
1943   },
1944   {
1945     "comment",
1946     14,
1947     PROTOBUF_C_LABEL_OPTIONAL,
1948     PROTOBUF_C_TYPE_STRING,
1949     0,   /* quantifier_offset */
1950     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment),
1951     NULL,
1952     NULL,
1953     0,            /* packed */
1954     0,NULL,NULL    /* reserved1,reserved2, etc */
1955   },
1956   {
1957     "hash",
1958     15,
1959     PROTOBUF_C_LABEL_OPTIONAL,
1960     PROTOBUF_C_TYPE_STRING,
1961     0,   /* quantifier_offset */
1962     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, hash),
1963     NULL,
1964     NULL,
1965     0,            /* packed */
1966     0,NULL,NULL    /* reserved1,reserved2, etc */
1967   },
1968 };
1969 static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
1970   1,   /* field[1] = actor */
1971   4,   /* field[4] = channel_id */
1972   13,   /* field[13] = comment */
1973   6,   /* field[6] = deaf */
1974   14,   /* field[14] = hash */
1975   5,   /* field[5] = mute */
1976   2,   /* field[2] = name */
1977   11,   /* field[11] = plugin_context */
1978   12,   /* field[12] = plugin_identity */
1979   9,   /* field[9] = self_deaf */
1980   8,   /* field[8] = self_mute */
1981   0,   /* field[0] = session */
1982   7,   /* field[7] = suppress */
1983   10,   /* field[10] = texture */
1984   3,   /* field[3] = user_id */
1985 };
1986 static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
1987 {
1988   { 1, 0 },
1989   { 0, 15 }
1990 };
1991 const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
1992 {
1993   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1994   "MumbleProto.UserState",
1995   "UserState",
1996   "MumbleProto__UserState",
1997   "MumbleProto",
1998   sizeof(MumbleProto__UserState),
1999   15,
2000   mumble_proto__user_state__field_descriptors,
2001   mumble_proto__user_state__field_indices_by_name,
2002   1,  mumble_proto__user_state__number_ranges,
2003   (ProtobufCMessageInit) mumble_proto__user_state__init,
2004   NULL,NULL,NULL    /* reserved[123] */
2005 };
2006 static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
2007 {
2008   {
2009     "address",
2010     1,
2011     PROTOBUF_C_LABEL_REQUIRED,
2012     PROTOBUF_C_TYPE_BYTES,
2013     0,   /* quantifier_offset */
2014     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, address),
2015     NULL,
2016     NULL,
2017     0,            /* packed */
2018     0,NULL,NULL    /* reserved1,reserved2, etc */
2019   },
2020   {
2021     "mask",
2022     2,
2023     PROTOBUF_C_LABEL_REQUIRED,
2024     PROTOBUF_C_TYPE_UINT32,
2025     0,   /* quantifier_offset */
2026     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, mask),
2027     NULL,
2028     NULL,
2029     0,            /* packed */
2030     0,NULL,NULL    /* reserved1,reserved2, etc */
2031   },
2032   {
2033     "name",
2034     3,
2035     PROTOBUF_C_LABEL_OPTIONAL,
2036     PROTOBUF_C_TYPE_STRING,
2037     0,   /* quantifier_offset */
2038     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, name),
2039     NULL,
2040     NULL,
2041     0,            /* packed */
2042     0,NULL,NULL    /* reserved1,reserved2, etc */
2043   },
2044   {
2045     "hash",
2046     4,
2047     PROTOBUF_C_LABEL_OPTIONAL,
2048     PROTOBUF_C_TYPE_STRING,
2049     0,   /* quantifier_offset */
2050     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, hash),
2051     NULL,
2052     NULL,
2053     0,            /* packed */
2054     0,NULL,NULL    /* reserved1,reserved2, etc */
2055   },
2056   {
2057     "reason",
2058     5,
2059     PROTOBUF_C_LABEL_OPTIONAL,
2060     PROTOBUF_C_TYPE_STRING,
2061     0,   /* quantifier_offset */
2062     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, reason),
2063     NULL,
2064     NULL,
2065     0,            /* packed */
2066     0,NULL,NULL    /* reserved1,reserved2, etc */
2067   },
2068   {
2069     "start",
2070     6,
2071     PROTOBUF_C_LABEL_OPTIONAL,
2072     PROTOBUF_C_TYPE_STRING,
2073     0,   /* quantifier_offset */
2074     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, start),
2075     NULL,
2076     NULL,
2077     0,            /* packed */
2078     0,NULL,NULL    /* reserved1,reserved2, etc */
2079   },
2080   {
2081     "duration",
2082     7,
2083     PROTOBUF_C_LABEL_OPTIONAL,
2084     PROTOBUF_C_TYPE_UINT32,
2085     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, has_duration),
2086     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, duration),
2087     NULL,
2088     NULL,
2089     0,            /* packed */
2090     0,NULL,NULL    /* reserved1,reserved2, etc */
2091   },
2092 };
2093 static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
2094   0,   /* field[0] = address */
2095   6,   /* field[6] = duration */
2096   3,   /* field[3] = hash */
2097   1,   /* field[1] = mask */
2098   2,   /* field[2] = name */
2099   4,   /* field[4] = reason */
2100   5,   /* field[5] = start */
2101 };
2102 static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
2103 {
2104   { 1, 0 },
2105   { 0, 7 }
2106 };
2107 const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
2108 {
2109   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2110   "MumbleProto.BanList.BanEntry",
2111   "BanEntry",
2112   "MumbleProto__BanList__BanEntry",
2113   "MumbleProto",
2114   sizeof(MumbleProto__BanList__BanEntry),
2115   7,
2116   mumble_proto__ban_list__ban_entry__field_descriptors,
2117   mumble_proto__ban_list__ban_entry__field_indices_by_name,
2118   1,  mumble_proto__ban_list__ban_entry__number_ranges,
2119   (ProtobufCMessageInit) mumble_proto__ban_list__ban_entry__init,
2120   NULL,NULL,NULL    /* reserved[123] */
2121 };
2122 static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
2123 static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
2124 {
2125   {
2126     "bans",
2127     1,
2128     PROTOBUF_C_LABEL_REPEATED,
2129     PROTOBUF_C_TYPE_MESSAGE,
2130     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, n_bans),
2131     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, bans),
2132     &mumble_proto__ban_list__ban_entry__descriptor,
2133     NULL,
2134     0,            /* packed */
2135     0,NULL,NULL    /* reserved1,reserved2, etc */
2136   },
2137   {
2138     "query",
2139     2,
2140     PROTOBUF_C_LABEL_OPTIONAL,
2141     PROTOBUF_C_TYPE_BOOL,
2142     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, has_query),
2143     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, query),
2144     NULL,
2145     &mumble_proto__ban_list__query__default_value,
2146     0,            /* packed */
2147     0,NULL,NULL    /* reserved1,reserved2, etc */
2148   },
2149 };
2150 static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
2151   0,   /* field[0] = bans */
2152   1,   /* field[1] = query */
2153 };
2154 static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
2155 {
2156   { 1, 0 },
2157   { 0, 2 }
2158 };
2159 const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
2160 {
2161   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2162   "MumbleProto.BanList",
2163   "BanList",
2164   "MumbleProto__BanList",
2165   "MumbleProto",
2166   sizeof(MumbleProto__BanList),
2167   2,
2168   mumble_proto__ban_list__field_descriptors,
2169   mumble_proto__ban_list__field_indices_by_name,
2170   1,  mumble_proto__ban_list__number_ranges,
2171   (ProtobufCMessageInit) mumble_proto__ban_list__init,
2172   NULL,NULL,NULL    /* reserved[123] */
2173 };
2174 static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
2175 {
2176   {
2177     "actor",
2178     1,
2179     PROTOBUF_C_LABEL_OPTIONAL,
2180     PROTOBUF_C_TYPE_UINT32,
2181     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, has_actor),
2182     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, actor),
2183     NULL,
2184     NULL,
2185     0,            /* packed */
2186     0,NULL,NULL    /* reserved1,reserved2, etc */
2187   },
2188   {
2189     "session",
2190     2,
2191     PROTOBUF_C_LABEL_REPEATED,
2192     PROTOBUF_C_TYPE_UINT32,
2193     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_session),
2194     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, session),
2195     NULL,
2196     NULL,
2197     0,            /* packed */
2198     0,NULL,NULL    /* reserved1,reserved2, etc */
2199   },
2200   {
2201     "channel_id",
2202     3,
2203     PROTOBUF_C_LABEL_REPEATED,
2204     PROTOBUF_C_TYPE_UINT32,
2205     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_channel_id),
2206     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, channel_id),
2207     NULL,
2208     NULL,
2209     0,            /* packed */
2210     0,NULL,NULL    /* reserved1,reserved2, etc */
2211   },
2212   {
2213     "tree_id",
2214     4,
2215     PROTOBUF_C_LABEL_REPEATED,
2216     PROTOBUF_C_TYPE_UINT32,
2217     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_tree_id),
2218     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, tree_id),
2219     NULL,
2220     NULL,
2221     0,            /* packed */
2222     0,NULL,NULL    /* reserved1,reserved2, etc */
2223   },
2224   {
2225     "message",
2226     5,
2227     PROTOBUF_C_LABEL_REQUIRED,
2228     PROTOBUF_C_TYPE_STRING,
2229     0,   /* quantifier_offset */
2230     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, message),
2231     NULL,
2232     NULL,
2233     0,            /* packed */
2234     0,NULL,NULL    /* reserved1,reserved2, etc */
2235   },
2236 };
2237 static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
2238   0,   /* field[0] = actor */
2239   2,   /* field[2] = channel_id */
2240   4,   /* field[4] = message */
2241   1,   /* field[1] = session */
2242   3,   /* field[3] = tree_id */
2243 };
2244 static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
2245 {
2246   { 1, 0 },
2247   { 0, 5 }
2248 };
2249 const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
2250 {
2251   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2252   "MumbleProto.TextMessage",
2253   "TextMessage",
2254   "MumbleProto__TextMessage",
2255   "MumbleProto",
2256   sizeof(MumbleProto__TextMessage),
2257   5,
2258   mumble_proto__text_message__field_descriptors,
2259   mumble_proto__text_message__field_indices_by_name,
2260   1,  mumble_proto__text_message__number_ranges,
2261   (ProtobufCMessageInit) mumble_proto__text_message__init,
2262   NULL,NULL,NULL    /* reserved[123] */
2263 };
2264 const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[8] =
2265 {
2266   { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXT", 0 },
2267   { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__PERMISSION", 1 },
2268   { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SUPERUSER", 2 },
2269   { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__CHANNELNAME", 3 },
2270   { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXTTOOLONG", 4 },
2271   { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
2272   { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEMPORARYCHANNEL", 6 },
2273   { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MISSINGCERTIFICATE", 7 },
2274 };
2275 static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
2276 {0, 0},{0, 8}
2277 };
2278 const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[8] =
2279 {
2280   { "ChannelName", 3 },
2281   { "H9K", 5 },
2282   { "MissingCertificate", 7 },
2283   { "Permission", 1 },
2284   { "SuperUser", 2 },
2285   { "TemporaryChannel", 6 },
2286   { "Text", 0 },
2287   { "TextTooLong", 4 },
2288 };
2289 const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
2290 {
2291   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
2292   "MumbleProto.PermissionDenied.DenyType",
2293   "DenyType",
2294   "MumbleProto__PermissionDenied__DenyType",
2295   "MumbleProto",
2296   8,
2297   mumble_proto__permission_denied__deny_type__enum_values_by_number,
2298   8,
2299   mumble_proto__permission_denied__deny_type__enum_values_by_name,
2300   1,
2301   mumble_proto__permission_denied__deny_type__value_ranges,
2302   NULL,NULL,NULL,NULL   /* reserved[1234] */
2303 };
2304 static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[5] =
2305 {
2306   {
2307     "permission",
2308     1,
2309     PROTOBUF_C_LABEL_OPTIONAL,
2310     PROTOBUF_C_TYPE_UINT32,
2311     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_permission),
2312     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, permission),
2313     NULL,
2314     NULL,
2315     0,            /* packed */
2316     0,NULL,NULL    /* reserved1,reserved2, etc */
2317   },
2318   {
2319     "channel_id",
2320     2,
2321     PROTOBUF_C_LABEL_OPTIONAL,
2322     PROTOBUF_C_TYPE_UINT32,
2323     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_channel_id),
2324     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, channel_id),
2325     NULL,
2326     NULL,
2327     0,            /* packed */
2328     0,NULL,NULL    /* reserved1,reserved2, etc */
2329   },
2330   {
2331     "session",
2332     3,
2333     PROTOBUF_C_LABEL_OPTIONAL,
2334     PROTOBUF_C_TYPE_UINT32,
2335     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_session),
2336     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, session),
2337     NULL,
2338     NULL,
2339     0,            /* packed */
2340     0,NULL,NULL    /* reserved1,reserved2, etc */
2341   },
2342   {
2343     "reason",
2344     4,
2345     PROTOBUF_C_LABEL_OPTIONAL,
2346     PROTOBUF_C_TYPE_STRING,
2347     0,   /* quantifier_offset */
2348     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, reason),
2349     NULL,
2350     NULL,
2351     0,            /* packed */
2352     0,NULL,NULL    /* reserved1,reserved2, etc */
2353   },
2354   {
2355     "type",
2356     5,
2357     PROTOBUF_C_LABEL_OPTIONAL,
2358     PROTOBUF_C_TYPE_ENUM,
2359     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_type),
2360     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, type),
2361     &mumble_proto__permission_denied__deny_type__descriptor,
2362     NULL,
2363     0,            /* packed */
2364     0,NULL,NULL    /* reserved1,reserved2, etc */
2365   },
2366 };
2367 static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
2368   1,   /* field[1] = channel_id */
2369   0,   /* field[0] = permission */
2370   3,   /* field[3] = reason */
2371   2,   /* field[2] = session */
2372   4,   /* field[4] = type */
2373 };
2374 static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
2375 {
2376   { 1, 0 },
2377   { 0, 5 }
2378 };
2379 const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
2380 {
2381   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2382   "MumbleProto.PermissionDenied",
2383   "PermissionDenied",
2384   "MumbleProto__PermissionDenied",
2385   "MumbleProto",
2386   sizeof(MumbleProto__PermissionDenied),
2387   5,
2388   mumble_proto__permission_denied__field_descriptors,
2389   mumble_proto__permission_denied__field_indices_by_name,
2390   1,  mumble_proto__permission_denied__number_ranges,
2391   (ProtobufCMessageInit) mumble_proto__permission_denied__init,
2392   NULL,NULL,NULL    /* reserved[123] */
2393 };
2394 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
2395 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
2396 static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
2397 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
2398 {
2399   {
2400     "name",
2401     1,
2402     PROTOBUF_C_LABEL_REQUIRED,
2403     PROTOBUF_C_TYPE_STRING,
2404     0,   /* quantifier_offset */
2405     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, name),
2406     NULL,
2407     NULL,
2408     0,            /* packed */
2409     0,NULL,NULL    /* reserved1,reserved2, etc */
2410   },
2411   {
2412     "inherited",
2413     2,
2414     PROTOBUF_C_LABEL_OPTIONAL,
2415     PROTOBUF_C_TYPE_BOOL,
2416     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherited),
2417     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited),
2418     NULL,
2419     &mumble_proto__acl__chan_group__inherited__default_value,
2420     0,            /* packed */
2421     0,NULL,NULL    /* reserved1,reserved2, etc */
2422   },
2423   {
2424     "inherit",
2425     3,
2426     PROTOBUF_C_LABEL_OPTIONAL,
2427     PROTOBUF_C_TYPE_BOOL,
2428     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherit),
2429     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherit),
2430     NULL,
2431     &mumble_proto__acl__chan_group__inherit__default_value,
2432     0,            /* packed */
2433     0,NULL,NULL    /* reserved1,reserved2, etc */
2434   },
2435   {
2436     "inheritable",
2437     4,
2438     PROTOBUF_C_LABEL_OPTIONAL,
2439     PROTOBUF_C_TYPE_BOOL,
2440     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inheritable),
2441     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inheritable),
2442     NULL,
2443     &mumble_proto__acl__chan_group__inheritable__default_value,
2444     0,            /* packed */
2445     0,NULL,NULL    /* reserved1,reserved2, etc */
2446   },
2447   {
2448     "add",
2449     5,
2450     PROTOBUF_C_LABEL_REPEATED,
2451     PROTOBUF_C_TYPE_UINT32,
2452     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_add),
2453     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, add),
2454     NULL,
2455     NULL,
2456     0,            /* packed */
2457     0,NULL,NULL    /* reserved1,reserved2, etc */
2458   },
2459   {
2460     "remove",
2461     6,
2462     PROTOBUF_C_LABEL_REPEATED,
2463     PROTOBUF_C_TYPE_UINT32,
2464     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_remove),
2465     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, remove),
2466     NULL,
2467     NULL,
2468     0,            /* packed */
2469     0,NULL,NULL    /* reserved1,reserved2, etc */
2470   },
2471   {
2472     "inherited_members",
2473     7,
2474     PROTOBUF_C_LABEL_REPEATED,
2475     PROTOBUF_C_TYPE_UINT32,
2476     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_inherited_members),
2477     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited_members),
2478     NULL,
2479     NULL,
2480     0,            /* packed */
2481     0,NULL,NULL    /* reserved1,reserved2, etc */
2482   },
2483 };
2484 static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
2485   4,   /* field[4] = add */
2486   2,   /* field[2] = inherit */
2487   3,   /* field[3] = inheritable */
2488   1,   /* field[1] = inherited */
2489   6,   /* field[6] = inherited_members */
2490   0,   /* field[0] = name */
2491   5,   /* field[5] = remove */
2492 };
2493 static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
2494 {
2495   { 1, 0 },
2496   { 0, 7 }
2497 };
2498 const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
2499 {
2500   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2501   "MumbleProto.ACL.ChanGroup",
2502   "ChanGroup",
2503   "MumbleProto__ACL__ChanGroup",
2504   "MumbleProto",
2505   sizeof(MumbleProto__ACL__ChanGroup),
2506   7,
2507   mumble_proto__acl__chan_group__field_descriptors,
2508   mumble_proto__acl__chan_group__field_indices_by_name,
2509   1,  mumble_proto__acl__chan_group__number_ranges,
2510   (ProtobufCMessageInit) mumble_proto__acl__chan_group__init,
2511   NULL,NULL,NULL    /* reserved[123] */
2512 };
2513 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
2514 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
2515 static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
2516 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
2517 {
2518   {
2519     "apply_here",
2520     1,
2521     PROTOBUF_C_LABEL_OPTIONAL,
2522     PROTOBUF_C_TYPE_BOOL,
2523     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_here),
2524     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_here),
2525     NULL,
2526     &mumble_proto__acl__chan_acl__apply_here__default_value,
2527     0,            /* packed */
2528     0,NULL,NULL    /* reserved1,reserved2, etc */
2529   },
2530   {
2531     "apply_subs",
2532     2,
2533     PROTOBUF_C_LABEL_OPTIONAL,
2534     PROTOBUF_C_TYPE_BOOL,
2535     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_subs),
2536     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_subs),
2537     NULL,
2538     &mumble_proto__acl__chan_acl__apply_subs__default_value,
2539     0,            /* packed */
2540     0,NULL,NULL    /* reserved1,reserved2, etc */
2541   },
2542   {
2543     "inherited",
2544     3,
2545     PROTOBUF_C_LABEL_OPTIONAL,
2546     PROTOBUF_C_TYPE_BOOL,
2547     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_inherited),
2548     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, inherited),
2549     NULL,
2550     &mumble_proto__acl__chan_acl__inherited__default_value,
2551     0,            /* packed */
2552     0,NULL,NULL    /* reserved1,reserved2, etc */
2553   },
2554   {
2555     "user_id",
2556     4,
2557     PROTOBUF_C_LABEL_OPTIONAL,
2558     PROTOBUF_C_TYPE_UINT32,
2559     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_user_id),
2560     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, user_id),
2561     NULL,
2562     NULL,
2563     0,            /* packed */
2564     0,NULL,NULL    /* reserved1,reserved2, etc */
2565   },
2566   {
2567     "group",
2568     5,
2569     PROTOBUF_C_LABEL_OPTIONAL,
2570     PROTOBUF_C_TYPE_STRING,
2571     0,   /* quantifier_offset */
2572     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, group),
2573     NULL,
2574     NULL,
2575     0,            /* packed */
2576     0,NULL,NULL    /* reserved1,reserved2, etc */
2577   },
2578   {
2579     "grant",
2580     6,
2581     PROTOBUF_C_LABEL_OPTIONAL,
2582     PROTOBUF_C_TYPE_UINT32,
2583     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_grant),
2584     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, grant),
2585     NULL,
2586     NULL,
2587     0,            /* packed */
2588     0,NULL,NULL    /* reserved1,reserved2, etc */
2589   },
2590   {
2591     "deny",
2592     7,
2593     PROTOBUF_C_LABEL_OPTIONAL,
2594     PROTOBUF_C_TYPE_UINT32,
2595     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_deny),
2596     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, deny),
2597     NULL,
2598     NULL,
2599     0,            /* packed */
2600     0,NULL,NULL    /* reserved1,reserved2, etc */
2601   },
2602 };
2603 static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
2604   0,   /* field[0] = apply_here */
2605   1,   /* field[1] = apply_subs */
2606   6,   /* field[6] = deny */
2607   5,   /* field[5] = grant */
2608   4,   /* field[4] = group */
2609   2,   /* field[2] = inherited */
2610   3,   /* field[3] = user_id */
2611 };
2612 static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
2613 {
2614   { 1, 0 },
2615   { 0, 7 }
2616 };
2617 const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
2618 {
2619   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2620   "MumbleProto.ACL.ChanACL",
2621   "ChanACL",
2622   "MumbleProto__ACL__ChanACL",
2623   "MumbleProto",
2624   sizeof(MumbleProto__ACL__ChanACL),
2625   7,
2626   mumble_proto__acl__chan_acl__field_descriptors,
2627   mumble_proto__acl__chan_acl__field_indices_by_name,
2628   1,  mumble_proto__acl__chan_acl__number_ranges,
2629   (ProtobufCMessageInit) mumble_proto__acl__chan_acl__init,
2630   NULL,NULL,NULL    /* reserved[123] */
2631 };
2632 static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
2633 static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
2634 static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
2635 {
2636   {
2637     "channel_id",
2638     1,
2639     PROTOBUF_C_LABEL_REQUIRED,
2640     PROTOBUF_C_TYPE_UINT32,
2641     0,   /* quantifier_offset */
2642     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, channel_id),
2643     NULL,
2644     NULL,
2645     0,            /* packed */
2646     0,NULL,NULL    /* reserved1,reserved2, etc */
2647   },
2648   {
2649     "inherit_acls",
2650     2,
2651     PROTOBUF_C_LABEL_OPTIONAL,
2652     PROTOBUF_C_TYPE_BOOL,
2653     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_inherit_acls),
2654     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, inherit_acls),
2655     NULL,
2656     &mumble_proto__acl__inherit_acls__default_value,
2657     0,            /* packed */
2658     0,NULL,NULL    /* reserved1,reserved2, etc */
2659   },
2660   {
2661     "groups",
2662     3,
2663     PROTOBUF_C_LABEL_REPEATED,
2664     PROTOBUF_C_TYPE_MESSAGE,
2665     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_groups),
2666     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, groups),
2667     &mumble_proto__acl__chan_group__descriptor,
2668     NULL,
2669     0,            /* packed */
2670     0,NULL,NULL    /* reserved1,reserved2, etc */
2671   },
2672   {
2673     "acls",
2674     4,
2675     PROTOBUF_C_LABEL_REPEATED,
2676     PROTOBUF_C_TYPE_MESSAGE,
2677     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_acls),
2678     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, acls),
2679     &mumble_proto__acl__chan_acl__descriptor,
2680     NULL,
2681     0,            /* packed */
2682     0,NULL,NULL    /* reserved1,reserved2, etc */
2683   },
2684   {
2685     "query",
2686     5,
2687     PROTOBUF_C_LABEL_OPTIONAL,
2688     PROTOBUF_C_TYPE_BOOL,
2689     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_query),
2690     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, query),
2691     NULL,
2692     &mumble_proto__acl__query__default_value,
2693     0,            /* packed */
2694     0,NULL,NULL    /* reserved1,reserved2, etc */
2695   },
2696 };
2697 static const unsigned mumble_proto__acl__field_indices_by_name[] = {
2698   3,   /* field[3] = acls */
2699   0,   /* field[0] = channel_id */
2700   2,   /* field[2] = groups */
2701   1,   /* field[1] = inherit_acls */
2702   4,   /* field[4] = query */
2703 };
2704 static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
2705 {
2706   { 1, 0 },
2707   { 0, 5 }
2708 };
2709 const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
2710 {
2711   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2712   "MumbleProto.ACL",
2713   "ACL",
2714   "MumbleProto__ACL",
2715   "MumbleProto",
2716   sizeof(MumbleProto__ACL),
2717   5,
2718   mumble_proto__acl__field_descriptors,
2719   mumble_proto__acl__field_indices_by_name,
2720   1,  mumble_proto__acl__number_ranges,
2721   (ProtobufCMessageInit) mumble_proto__acl__init,
2722   NULL,NULL,NULL    /* reserved[123] */
2723 };
2724 static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
2725 {
2726   {
2727     "ids",
2728     1,
2729     PROTOBUF_C_LABEL_REPEATED,
2730     PROTOBUF_C_TYPE_UINT32,
2731     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_ids),
2732     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, ids),
2733     NULL,
2734     NULL,
2735     0,            /* packed */
2736     0,NULL,NULL    /* reserved1,reserved2, etc */
2737   },
2738   {
2739     "names",
2740     2,
2741     PROTOBUF_C_LABEL_REPEATED,
2742     PROTOBUF_C_TYPE_STRING,
2743     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_names),
2744     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, names),
2745     NULL,
2746     NULL,
2747     0,            /* packed */
2748     0,NULL,NULL    /* reserved1,reserved2, etc */
2749   },
2750 };
2751 static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
2752   0,   /* field[0] = ids */
2753   1,   /* field[1] = names */
2754 };
2755 static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
2756 {
2757   { 1, 0 },
2758   { 0, 2 }
2759 };
2760 const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
2761 {
2762   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2763   "MumbleProto.QueryUsers",
2764   "QueryUsers",
2765   "MumbleProto__QueryUsers",
2766   "MumbleProto",
2767   sizeof(MumbleProto__QueryUsers),
2768   2,
2769   mumble_proto__query_users__field_descriptors,
2770   mumble_proto__query_users__field_indices_by_name,
2771   1,  mumble_proto__query_users__number_ranges,
2772   (ProtobufCMessageInit) mumble_proto__query_users__init,
2773   NULL,NULL,NULL    /* reserved[123] */
2774 };
2775 static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
2776 {
2777   {
2778     "key",
2779     1,
2780     PROTOBUF_C_LABEL_OPTIONAL,
2781     PROTOBUF_C_TYPE_BYTES,
2782     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_key),
2783     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, key),
2784     NULL,
2785     NULL,
2786     0,            /* packed */
2787     0,NULL,NULL    /* reserved1,reserved2, etc */
2788   },
2789   {
2790     "client_nonce",
2791     2,
2792     PROTOBUF_C_LABEL_OPTIONAL,
2793     PROTOBUF_C_TYPE_BYTES,
2794     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_client_nonce),
2795     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, client_nonce),
2796     NULL,
2797     NULL,
2798     0,            /* packed */
2799     0,NULL,NULL    /* reserved1,reserved2, etc */
2800   },
2801   {
2802     "server_nonce",
2803     3,
2804     PROTOBUF_C_LABEL_OPTIONAL,
2805     PROTOBUF_C_TYPE_BYTES,
2806     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_server_nonce),
2807     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, server_nonce),
2808     NULL,
2809     NULL,
2810     0,            /* packed */
2811     0,NULL,NULL    /* reserved1,reserved2, etc */
2812   },
2813 };
2814 static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
2815   1,   /* field[1] = client_nonce */
2816   0,   /* field[0] = key */
2817   2,   /* field[2] = server_nonce */
2818 };
2819 static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
2820 {
2821   { 1, 0 },
2822   { 0, 3 }
2823 };
2824 const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
2825 {
2826   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2827   "MumbleProto.CryptSetup",
2828   "CryptSetup",
2829   "MumbleProto__CryptSetup",
2830   "MumbleProto",
2831   sizeof(MumbleProto__CryptSetup),
2832   3,
2833   mumble_proto__crypt_setup__field_descriptors,
2834   mumble_proto__crypt_setup__field_indices_by_name,
2835   1,  mumble_proto__crypt_setup__number_ranges,
2836   (ProtobufCMessageInit) mumble_proto__crypt_setup__init,
2837   NULL,NULL,NULL    /* reserved[123] */
2838 };
2839 const ProtobufCEnumValue mumble_proto__context_action_add__context__enum_values_by_number[3] =
2840 {
2841   { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__SERVER", 1 },
2842   { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__CHANNEL", 2 },
2843   { "User", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__USER", 4 },
2844 };
2845 static const ProtobufCIntRange mumble_proto__context_action_add__context__value_ranges[] = {
2846 {1, 0},{4, 2},{0, 3}
2847 };
2848 const ProtobufCEnumValueIndex mumble_proto__context_action_add__context__enum_values_by_name[3] =
2849 {
2850   { "Channel", 1 },
2851   { "Server", 0 },
2852   { "User", 2 },
2853 };
2854 const ProtobufCEnumDescriptor mumble_proto__context_action_add__context__descriptor =
2855 {
2856   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
2857   "MumbleProto.ContextActionAdd.Context",
2858   "Context",
2859   "MumbleProto__ContextActionAdd__Context",
2860   "MumbleProto",
2861   3,
2862   mumble_proto__context_action_add__context__enum_values_by_number,
2863   3,
2864   mumble_proto__context_action_add__context__enum_values_by_name,
2865   2,
2866   mumble_proto__context_action_add__context__value_ranges,
2867   NULL,NULL,NULL,NULL   /* reserved[1234] */
2868 };
2869 static const ProtobufCFieldDescriptor mumble_proto__context_action_add__field_descriptors[3] =
2870 {
2871   {
2872     "action",
2873     1,
2874     PROTOBUF_C_LABEL_REQUIRED,
2875     PROTOBUF_C_TYPE_STRING,
2876     0,   /* quantifier_offset */
2877     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, action),
2878     NULL,
2879     NULL,
2880     0,            /* packed */
2881     0,NULL,NULL    /* reserved1,reserved2, etc */
2882   },
2883   {
2884     "text",
2885     2,
2886     PROTOBUF_C_LABEL_REQUIRED,
2887     PROTOBUF_C_TYPE_STRING,
2888     0,   /* quantifier_offset */
2889     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, text),
2890     NULL,
2891     NULL,
2892     0,            /* packed */
2893     0,NULL,NULL    /* reserved1,reserved2, etc */
2894   },
2895   {
2896     "context",
2897     3,
2898     PROTOBUF_C_LABEL_OPTIONAL,
2899     PROTOBUF_C_TYPE_UINT32,
2900     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, has_context),
2901     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, context),
2902     NULL,
2903     NULL,
2904     0,            /* packed */
2905     0,NULL,NULL    /* reserved1,reserved2, etc */
2906   },
2907 };
2908 static const unsigned mumble_proto__context_action_add__field_indices_by_name[] = {
2909   0,   /* field[0] = action */
2910   2,   /* field[2] = context */
2911   1,   /* field[1] = text */
2912 };
2913 static const ProtobufCIntRange mumble_proto__context_action_add__number_ranges[1 + 1] =
2914 {
2915   { 1, 0 },
2916   { 0, 3 }
2917 };
2918 const ProtobufCMessageDescriptor mumble_proto__context_action_add__descriptor =
2919 {
2920   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2921   "MumbleProto.ContextActionAdd",
2922   "ContextActionAdd",
2923   "MumbleProto__ContextActionAdd",
2924   "MumbleProto",
2925   sizeof(MumbleProto__ContextActionAdd),
2926   3,
2927   mumble_proto__context_action_add__field_descriptors,
2928   mumble_proto__context_action_add__field_indices_by_name,
2929   1,  mumble_proto__context_action_add__number_ranges,
2930   (ProtobufCMessageInit) mumble_proto__context_action_add__init,
2931   NULL,NULL,NULL    /* reserved[123] */
2932 };
2933 static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
2934 {
2935   {
2936     "session",
2937     1,
2938     PROTOBUF_C_LABEL_OPTIONAL,
2939     PROTOBUF_C_TYPE_UINT32,
2940     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_session),
2941     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, session),
2942     NULL,
2943     NULL,
2944     0,            /* packed */
2945     0,NULL,NULL    /* reserved1,reserved2, etc */
2946   },
2947   {
2948     "channel_id",
2949     2,
2950     PROTOBUF_C_LABEL_OPTIONAL,
2951     PROTOBUF_C_TYPE_UINT32,
2952     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_channel_id),
2953     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, channel_id),
2954     NULL,
2955     NULL,
2956     0,            /* packed */
2957     0,NULL,NULL    /* reserved1,reserved2, etc */
2958   },
2959   {
2960     "action",
2961     3,
2962     PROTOBUF_C_LABEL_REQUIRED,
2963     PROTOBUF_C_TYPE_STRING,
2964     0,   /* quantifier_offset */
2965     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, action),
2966     NULL,
2967     NULL,
2968     0,            /* packed */
2969     0,NULL,NULL    /* reserved1,reserved2, etc */
2970   },
2971 };
2972 static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
2973   2,   /* field[2] = action */
2974   1,   /* field[1] = channel_id */
2975   0,   /* field[0] = session */
2976 };
2977 static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
2978 {
2979   { 1, 0 },
2980   { 0, 3 }
2981 };
2982 const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
2983 {
2984   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2985   "MumbleProto.ContextAction",
2986   "ContextAction",
2987   "MumbleProto__ContextAction",
2988   "MumbleProto",
2989   sizeof(MumbleProto__ContextAction),
2990   3,
2991   mumble_proto__context_action__field_descriptors,
2992   mumble_proto__context_action__field_indices_by_name,
2993   1,  mumble_proto__context_action__number_ranges,
2994   (ProtobufCMessageInit) mumble_proto__context_action__init,
2995   NULL,NULL,NULL    /* reserved[123] */
2996 };
2997 static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
2998 {
2999   {
3000     "user_id",
3001     1,
3002     PROTOBUF_C_LABEL_REQUIRED,
3003     PROTOBUF_C_TYPE_UINT32,
3004     0,   /* quantifier_offset */
3005     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, user_id),
3006     NULL,
3007     NULL,
3008     0,            /* packed */
3009     0,NULL,NULL    /* reserved1,reserved2, etc */
3010   },
3011   {
3012     "name",
3013     2,
3014     PROTOBUF_C_LABEL_OPTIONAL,
3015     PROTOBUF_C_TYPE_STRING,
3016     0,   /* quantifier_offset */
3017     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, name),
3018     NULL,
3019     NULL,
3020     0,            /* packed */
3021     0,NULL,NULL    /* reserved1,reserved2, etc */
3022   },
3023 };
3024 static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
3025   1,   /* field[1] = name */
3026   0,   /* field[0] = user_id */
3027 };
3028 static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
3029 {
3030   { 1, 0 },
3031   { 0, 2 }
3032 };
3033 const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
3034 {
3035   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3036   "MumbleProto.UserList.User",
3037   "User",
3038   "MumbleProto__UserList__User",
3039   "MumbleProto",
3040   sizeof(MumbleProto__UserList__User),
3041   2,
3042   mumble_proto__user_list__user__field_descriptors,
3043   mumble_proto__user_list__user__field_indices_by_name,
3044   1,  mumble_proto__user_list__user__number_ranges,
3045   (ProtobufCMessageInit) mumble_proto__user_list__user__init,
3046   NULL,NULL,NULL    /* reserved[123] */
3047 };
3048 static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
3049 {
3050   {
3051     "users",
3052     1,
3053     PROTOBUF_C_LABEL_REPEATED,
3054     PROTOBUF_C_TYPE_MESSAGE,
3055     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, n_users),
3056     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, users),
3057     &mumble_proto__user_list__user__descriptor,
3058     NULL,
3059     0,            /* packed */
3060     0,NULL,NULL    /* reserved1,reserved2, etc */
3061   },
3062 };
3063 static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
3064   0,   /* field[0] = users */
3065 };
3066 static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
3067 {
3068   { 1, 0 },
3069   { 0, 1 }
3070 };
3071 const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
3072 {
3073   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3074   "MumbleProto.UserList",
3075   "UserList",
3076   "MumbleProto__UserList",
3077   "MumbleProto",
3078   sizeof(MumbleProto__UserList),
3079   1,
3080   mumble_proto__user_list__field_descriptors,
3081   mumble_proto__user_list__field_indices_by_name,
3082   1,  mumble_proto__user_list__number_ranges,
3083   (ProtobufCMessageInit) mumble_proto__user_list__init,
3084   NULL,NULL,NULL    /* reserved[123] */
3085 };
3086 static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
3087 static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
3088 static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
3089 {
3090   {
3091     "session",
3092     1,
3093     PROTOBUF_C_LABEL_REPEATED,
3094     PROTOBUF_C_TYPE_UINT32,
3095     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, n_session),
3096     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, session),
3097     NULL,
3098     NULL,
3099     0,            /* packed */
3100     0,NULL,NULL    /* reserved1,reserved2, etc */
3101   },
3102   {
3103     "channel_id",
3104     2,
3105     PROTOBUF_C_LABEL_OPTIONAL,
3106     PROTOBUF_C_TYPE_UINT32,
3107     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_channel_id),
3108     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, channel_id),
3109     NULL,
3110     NULL,
3111     0,            /* packed */
3112     0,NULL,NULL    /* reserved1,reserved2, etc */
3113   },
3114   {
3115     "group",
3116     3,
3117     PROTOBUF_C_LABEL_OPTIONAL,
3118     PROTOBUF_C_TYPE_STRING,
3119     0,   /* quantifier_offset */
3120     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, group),
3121     NULL,
3122     NULL,
3123     0,            /* packed */
3124     0,NULL,NULL    /* reserved1,reserved2, etc */
3125   },
3126   {
3127     "links",
3128     4,
3129     PROTOBUF_C_LABEL_OPTIONAL,
3130     PROTOBUF_C_TYPE_BOOL,
3131     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_links),
3132     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, links),
3133     NULL,
3134     &mumble_proto__voice_target__target__links__default_value,
3135     0,            /* packed */
3136     0,NULL,NULL    /* reserved1,reserved2, etc */
3137   },
3138   {
3139     "children",
3140     5,
3141     PROTOBUF_C_LABEL_OPTIONAL,
3142     PROTOBUF_C_TYPE_BOOL,
3143     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_children),
3144     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, children),
3145     NULL,
3146     &mumble_proto__voice_target__target__children__default_value,
3147     0,            /* packed */
3148     0,NULL,NULL    /* reserved1,reserved2, etc */
3149   },
3150 };
3151 static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
3152   1,   /* field[1] = channel_id */
3153   4,   /* field[4] = children */
3154   2,   /* field[2] = group */
3155   3,   /* field[3] = links */
3156   0,   /* field[0] = session */
3157 };
3158 static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
3159 {
3160   { 1, 0 },
3161   { 0, 5 }
3162 };
3163 const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
3164 {
3165   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3166   "MumbleProto.VoiceTarget.Target",
3167   "Target",
3168   "MumbleProto__VoiceTarget__Target",
3169   "MumbleProto",
3170   sizeof(MumbleProto__VoiceTarget__Target),
3171   5,
3172   mumble_proto__voice_target__target__field_descriptors,
3173   mumble_proto__voice_target__target__field_indices_by_name,
3174   1,  mumble_proto__voice_target__target__number_ranges,
3175   (ProtobufCMessageInit) mumble_proto__voice_target__target__init,
3176   NULL,NULL,NULL    /* reserved[123] */
3177 };
3178 static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
3179 {
3180   {
3181     "id",
3182     1,
3183     PROTOBUF_C_LABEL_OPTIONAL,
3184     PROTOBUF_C_TYPE_UINT32,
3185     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, has_id),
3186     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, id),
3187     NULL,
3188     NULL,
3189     0,            /* packed */
3190     0,NULL,NULL    /* reserved1,reserved2, etc */
3191   },
3192   {
3193     "targets",
3194     2,
3195     PROTOBUF_C_LABEL_REPEATED,
3196     PROTOBUF_C_TYPE_MESSAGE,
3197     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, n_targets),
3198     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, targets),
3199     &mumble_proto__voice_target__target__descriptor,
3200     NULL,
3201     0,            /* packed */
3202     0,NULL,NULL    /* reserved1,reserved2, etc */
3203   },
3204 };
3205 static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
3206   0,   /* field[0] = id */
3207   1,   /* field[1] = targets */
3208 };
3209 static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
3210 {
3211   { 1, 0 },
3212   { 0, 2 }
3213 };
3214 const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
3215 {
3216   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3217   "MumbleProto.VoiceTarget",
3218   "VoiceTarget",
3219   "MumbleProto__VoiceTarget",
3220   "MumbleProto",
3221   sizeof(MumbleProto__VoiceTarget),
3222   2,
3223   mumble_proto__voice_target__field_descriptors,
3224   mumble_proto__voice_target__field_indices_by_name,
3225   1,  mumble_proto__voice_target__number_ranges,
3226   (ProtobufCMessageInit) mumble_proto__voice_target__init,
3227   NULL,NULL,NULL    /* reserved[123] */
3228 };
3229 static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
3230 static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
3231 {
3232   {
3233     "channel_id",
3234     1,
3235     PROTOBUF_C_LABEL_OPTIONAL,
3236     PROTOBUF_C_TYPE_UINT32,
3237     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_channel_id),
3238     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, channel_id),
3239     NULL,
3240     NULL,
3241     0,            /* packed */
3242     0,NULL,NULL    /* reserved1,reserved2, etc */
3243   },
3244   {
3245     "permissions",
3246     2,
3247     PROTOBUF_C_LABEL_OPTIONAL,
3248     PROTOBUF_C_TYPE_UINT32,
3249     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_permissions),
3250     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, permissions),
3251     NULL,
3252     NULL,
3253     0,            /* packed */
3254     0,NULL,NULL    /* reserved1,reserved2, etc */
3255   },
3256   {
3257     "flush",
3258     3,
3259     PROTOBUF_C_LABEL_OPTIONAL,
3260     PROTOBUF_C_TYPE_BOOL,
3261     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_flush),
3262     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, flush),
3263     NULL,
3264     &mumble_proto__permission_query__flush__default_value,
3265     0,            /* packed */
3266     0,NULL,NULL    /* reserved1,reserved2, etc */
3267   },
3268 };
3269 static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
3270   0,   /* field[0] = channel_id */
3271   2,   /* field[2] = flush */
3272   1,   /* field[1] = permissions */
3273 };
3274 static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
3275 {
3276   { 1, 0 },
3277   { 0, 3 }
3278 };
3279 const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
3280 {
3281   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3282   "MumbleProto.PermissionQuery",
3283   "PermissionQuery",
3284   "MumbleProto__PermissionQuery",
3285   "MumbleProto",
3286   sizeof(MumbleProto__PermissionQuery),
3287   3,
3288   mumble_proto__permission_query__field_descriptors,
3289   mumble_proto__permission_query__field_indices_by_name,
3290   1,  mumble_proto__permission_query__number_ranges,
3291   (ProtobufCMessageInit) mumble_proto__permission_query__init,
3292   NULL,NULL,NULL    /* reserved[123] */
3293 };
3294 static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
3295 static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[3] =
3296 {
3297   {
3298     "alpha",
3299     1,
3300     PROTOBUF_C_LABEL_REQUIRED,
3301     PROTOBUF_C_TYPE_INT32,
3302     0,   /* quantifier_offset */
3303     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, alpha),
3304     NULL,
3305     NULL,
3306     0,            /* packed */
3307     0,NULL,NULL    /* reserved1,reserved2, etc */
3308   },
3309   {
3310     "beta",
3311     2,
3312     PROTOBUF_C_LABEL_REQUIRED,
3313     PROTOBUF_C_TYPE_INT32,
3314     0,   /* quantifier_offset */
3315     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, beta),
3316     NULL,
3317     NULL,
3318     0,            /* packed */
3319     0,NULL,NULL    /* reserved1,reserved2, etc */
3320   },
3321   {
3322     "prefer_alpha",
3323     3,
3324     PROTOBUF_C_LABEL_REQUIRED,
3325     PROTOBUF_C_TYPE_BOOL,
3326     0,   /* quantifier_offset */
3327     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, prefer_alpha),
3328     NULL,
3329     &mumble_proto__codec_version__prefer_alpha__default_value,
3330     0,            /* packed */
3331     0,NULL,NULL    /* reserved1,reserved2, etc */
3332   },
3333 };
3334 static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
3335   0,   /* field[0] = alpha */
3336   1,   /* field[1] = beta */
3337   2,   /* field[2] = prefer_alpha */
3338 };
3339 static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
3340 {
3341   { 1, 0 },
3342   { 0, 3 }
3343 };
3344 const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
3345 {
3346   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3347   "MumbleProto.CodecVersion",
3348   "CodecVersion",
3349   "MumbleProto__CodecVersion",
3350   "MumbleProto",
3351   sizeof(MumbleProto__CodecVersion),
3352   3,
3353   mumble_proto__codec_version__field_descriptors,
3354   mumble_proto__codec_version__field_indices_by_name,
3355   1,  mumble_proto__codec_version__number_ranges,
3356   (ProtobufCMessageInit) mumble_proto__codec_version__init,
3357   NULL,NULL,NULL    /* reserved[123] */
3358 };