src/Mumble.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: Mumble.proto */
   3
   4 /* Do not generate deprecated warnings for self */
   5 #ifndef PROTOBUF_C__NO_DEPRECATED
   6 #define PROTOBUF_C__NO_DEPRECATED
   7 #endif
   8
   9 #include "Mumble.pb-c.h"
  10 void   mumble_proto__version__init
  11                      (MumbleProto__Version         *message)
  12 {
  13   static MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
  14   *message = init_value;
  15 }
  16 size_t mumble_proto__version__get_packed_size
  17                      (const MumbleProto__Version *message)
  18 {
  19   assert(message->base.descriptor == &mumble_proto__version__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t mumble_proto__version__pack
  23                      (const MumbleProto__Version *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &mumble_proto__version__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t mumble_proto__version__pack_to_buffer
  30                      (const MumbleProto__Version *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &mumble_proto__version__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 MumbleProto__Version *
  37        mumble_proto__version__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (MumbleProto__Version *)
  43      protobuf_c_message_unpack (&mumble_proto__version__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   mumble_proto__version__free_unpacked
  47                      (MumbleProto__Version *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   assert(message->base.descriptor == &mumble_proto__version__descriptor);
  51   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  52 }
  53 void   mumble_proto__udptunnel__init
  54                      (MumbleProto__UDPTunnel         *message)
  55 {
  56   static MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
  57   *message = init_value;
  58 }
  59 size_t mumble_proto__udptunnel__get_packed_size
  60                      (const MumbleProto__UDPTunnel *message)
  61 {
  62   assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  63   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  64 }
  65 size_t mumble_proto__udptunnel__pack
  66                      (const MumbleProto__UDPTunnel *message,
  67                       uint8_t       *out)
  68 {
  69   assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  70   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  71 }
  72 size_t mumble_proto__udptunnel__pack_to_buffer
  73                      (const MumbleProto__UDPTunnel *message,
  74                       ProtobufCBuffer *buffer)
  75 {
  76   assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  77   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  78 }
  79 MumbleProto__UDPTunnel *
  80        mumble_proto__udptunnel__unpack
  81                      (ProtobufCAllocator  *allocator,
  82                       size_t               len,
  83                       const uint8_t       *data)
  84 {
  85   return (MumbleProto__UDPTunnel *)
  86      protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
  87                                 allocator, len, data);
  88 }
  89 void   mumble_proto__udptunnel__free_unpacked
  90                      (MumbleProto__UDPTunnel *message,
  91                       ProtobufCAllocator *allocator)
  92 {
  93   assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  94   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  95 }
  96 void   mumble_proto__authenticate__init
  97                      (MumbleProto__Authenticate         *message)
  98 {
  99   static MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
 100   *message = init_value;
 101 }
 102 size_t mumble_proto__authenticate__get_packed_size
 103                      (const MumbleProto__Authenticate *message)
 104 {
 105   assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
 106   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 107 }
 108 size_t mumble_proto__authenticate__pack
 109                      (const MumbleProto__Authenticate *message,
 110                       uint8_t       *out)
 111 {
 112   assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
 113   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 114 }
 115 size_t mumble_proto__authenticate__pack_to_buffer
 116                      (const MumbleProto__Authenticate *message,
 117                       ProtobufCBuffer *buffer)
 118 {
 119   assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
 120   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 121 }
 122 MumbleProto__Authenticate *
 123        mumble_proto__authenticate__unpack
 124                      (ProtobufCAllocator  *allocator,
 125                       size_t               len,
 126                       const uint8_t       *data)
 127 {
 128   return (MumbleProto__Authenticate *)
 129      protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
 130                                 allocator, len, data);
 131 }
 132 void   mumble_proto__authenticate__free_unpacked
 133                      (MumbleProto__Authenticate *message,
 134                       ProtobufCAllocator *allocator)
 135 {
 136   assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
 137   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 138 }
 139 void   mumble_proto__ping__init
 140                      (MumbleProto__Ping         *message)
 141 {
 142   static MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
 143   *message = init_value;
 144 }
 145 size_t mumble_proto__ping__get_packed_size
 146                      (const MumbleProto__Ping *message)
 147 {
 148   assert(message->base.descriptor == &mumble_proto__ping__descriptor);
 149   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 150 }
 151 size_t mumble_proto__ping__pack
 152                      (const MumbleProto__Ping *message,
 153                       uint8_t       *out)
 154 {
 155   assert(message->base.descriptor == &mumble_proto__ping__descriptor);
 156   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 157 }
 158 size_t mumble_proto__ping__pack_to_buffer
 159                      (const MumbleProto__Ping *message,
 160                       ProtobufCBuffer *buffer)
 161 {
 162   assert(message->base.descriptor == &mumble_proto__ping__descriptor);
 163   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 164 }
 165 MumbleProto__Ping *
 166        mumble_proto__ping__unpack
 167                      (ProtobufCAllocator  *allocator,
 168                       size_t               len,
 169                       const uint8_t       *data)
 170 {
 171   return (MumbleProto__Ping *)
 172      protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
 173                                 allocator, len, data);
 174 }
 175 void   mumble_proto__ping__free_unpacked
 176                      (MumbleProto__Ping *message,
 177                       ProtobufCAllocator *allocator)
 178 {
 179   assert(message->base.descriptor == &mumble_proto__ping__descriptor);
 180   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 181 }
 182 void   mumble_proto__reject__init
 183                      (MumbleProto__Reject         *message)
 184 {
 185   static MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
 186   *message = init_value;
 187 }
 188 size_t mumble_proto__reject__get_packed_size
 189                      (const MumbleProto__Reject *message)
 190 {
 191   assert(message->base.descriptor == &mumble_proto__reject__descriptor);
 192   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 193 }
 194 size_t mumble_proto__reject__pack
 195                      (const MumbleProto__Reject *message,
 196                       uint8_t       *out)
 197 {
 198   assert(message->base.descriptor == &mumble_proto__reject__descriptor);
 199   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 200 }
 201 size_t mumble_proto__reject__pack_to_buffer
 202                      (const MumbleProto__Reject *message,
 203                       ProtobufCBuffer *buffer)
 204 {
 205   assert(message->base.descriptor == &mumble_proto__reject__descriptor);
 206   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 207 }
 208 MumbleProto__Reject *
 209        mumble_proto__reject__unpack
 210                      (ProtobufCAllocator  *allocator,
 211                       size_t               len,
 212                       const uint8_t       *data)
 213 {
 214   return (MumbleProto__Reject *)
 215      protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
 216                                 allocator, len, data);
 217 }
 218 void   mumble_proto__reject__free_unpacked
 219                      (MumbleProto__Reject *message,
 220                       ProtobufCAllocator *allocator)
 221 {
 222   assert(message->base.descriptor == &mumble_proto__reject__descriptor);
 223   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 224 }
 225 void   mumble_proto__server_config__init
 226                      (MumbleProto__ServerConfig         *message)
 227 {
 228   static MumbleProto__ServerConfig init_value = MUMBLE_PROTO__SERVER_CONFIG__INIT;
 229   *message = init_value;
 230 }
 231 size_t mumble_proto__server_config__get_packed_size
 232                      (const MumbleProto__ServerConfig *message)
 233 {
 234   assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
 235   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 236 }
 237 size_t mumble_proto__server_config__pack
 238                      (const MumbleProto__ServerConfig *message,
 239                       uint8_t       *out)
 240 {
 241   assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
 242   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 243 }
 244 size_t mumble_proto__server_config__pack_to_buffer
 245                      (const MumbleProto__ServerConfig *message,
 246                       ProtobufCBuffer *buffer)
 247 {
 248   assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
 249   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 250 }
 251 MumbleProto__ServerConfig *
 252        mumble_proto__server_config__unpack
 253                      (ProtobufCAllocator  *allocator,
 254                       size_t               len,
 255                       const uint8_t       *data)
 256 {
 257   return (MumbleProto__ServerConfig *)
 258      protobuf_c_message_unpack (&mumble_proto__server_config__descriptor,
 259                                 allocator, len, data);
 260 }
 261 void   mumble_proto__server_config__free_unpacked
 262                      (MumbleProto__ServerConfig *message,
 263                       ProtobufCAllocator *allocator)
 264 {
 265   assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
 266   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 267 }
 268 void   mumble_proto__server_sync__init
 269                      (MumbleProto__ServerSync         *message)
 270 {
 271   static MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
 272   *message = init_value;
 273 }
 274 size_t mumble_proto__server_sync__get_packed_size
 275                      (const MumbleProto__ServerSync *message)
 276 {
 277   assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
 278   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 279 }
 280 size_t mumble_proto__server_sync__pack
 281                      (const MumbleProto__ServerSync *message,
 282                       uint8_t       *out)
 283 {
 284   assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
 285   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 286 }
 287 size_t mumble_proto__server_sync__pack_to_buffer
 288                      (const MumbleProto__ServerSync *message,
 289                       ProtobufCBuffer *buffer)
 290 {
 291   assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
 292   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 293 }
 294 MumbleProto__ServerSync *
 295        mumble_proto__server_sync__unpack
 296                      (ProtobufCAllocator  *allocator,
 297                       size_t               len,
 298                       const uint8_t       *data)
 299 {
 300   return (MumbleProto__ServerSync *)
 301      protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
 302                                 allocator, len, data);
 303 }
 304 void   mumble_proto__server_sync__free_unpacked
 305                      (MumbleProto__ServerSync *message,
 306                       ProtobufCAllocator *allocator)
 307 {
 308   assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
 309   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 310 }
 311 void   mumble_proto__channel_remove__init
 312                      (MumbleProto__ChannelRemove         *message)
 313 {
 314   static MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
 315   *message = init_value;
 316 }
 317 size_t mumble_proto__channel_remove__get_packed_size
 318                      (const MumbleProto__ChannelRemove *message)
 319 {
 320   assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 321   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 322 }
 323 size_t mumble_proto__channel_remove__pack
 324                      (const MumbleProto__ChannelRemove *message,
 325                       uint8_t       *out)
 326 {
 327   assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 328   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 329 }
 330 size_t mumble_proto__channel_remove__pack_to_buffer
 331                      (const MumbleProto__ChannelRemove *message,
 332                       ProtobufCBuffer *buffer)
 333 {
 334   assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 335   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 336 }
 337 MumbleProto__ChannelRemove *
 338        mumble_proto__channel_remove__unpack
 339                      (ProtobufCAllocator  *allocator,
 340                       size_t               len,
 341                       const uint8_t       *data)
 342 {
 343   return (MumbleProto__ChannelRemove *)
 344      protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
 345                                 allocator, len, data);
 346 }
 347 void   mumble_proto__channel_remove__free_unpacked
 348                      (MumbleProto__ChannelRemove *message,
 349                       ProtobufCAllocator *allocator)
 350 {
 351   assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 352   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 353 }
 354 void   mumble_proto__channel_state__init
 355                      (MumbleProto__ChannelState         *message)
 356 {
 357   static MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
 358   *message = init_value;
 359 }
 360 size_t mumble_proto__channel_state__get_packed_size
 361                      (const MumbleProto__ChannelState *message)
 362 {
 363   assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
 364   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 365 }
 366 size_t mumble_proto__channel_state__pack
 367                      (const MumbleProto__ChannelState *message,
 368                       uint8_t       *out)
 369 {
 370   assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
 371   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 372 }
 373 size_t mumble_proto__channel_state__pack_to_buffer
 374                      (const MumbleProto__ChannelState *message,
 375                       ProtobufCBuffer *buffer)
 376 {
 377   assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
 378   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 379 }
 380 MumbleProto__ChannelState *
 381        mumble_proto__channel_state__unpack
 382                      (ProtobufCAllocator  *allocator,
 383                       size_t               len,
 384                       const uint8_t       *data)
 385 {
 386   return (MumbleProto__ChannelState *)
 387      protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
 388                                 allocator, len, data);
 389 }
 390 void   mumble_proto__channel_state__free_unpacked
 391                      (MumbleProto__ChannelState *message,
 392                       ProtobufCAllocator *allocator)
 393 {
 394   assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
 395   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 396 }
 397 void   mumble_proto__user_remove__init
 398                      (MumbleProto__UserRemove         *message)
 399 {
 400   static MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
 401   *message = init_value;
 402 }
 403 size_t mumble_proto__user_remove__get_packed_size
 404                      (const MumbleProto__UserRemove *message)
 405 {
 406   assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
 407   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 408 }
 409 size_t mumble_proto__user_remove__pack
 410                      (const MumbleProto__UserRemove *message,
 411                       uint8_t       *out)
 412 {
 413   assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
 414   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 415 }
 416 size_t mumble_proto__user_remove__pack_to_buffer
 417                      (const MumbleProto__UserRemove *message,
 418                       ProtobufCBuffer *buffer)
 419 {
 420   assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
 421   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 422 }
 423 MumbleProto__UserRemove *
 424        mumble_proto__user_remove__unpack
 425                      (ProtobufCAllocator  *allocator,
 426                       size_t               len,
 427                       const uint8_t       *data)
 428 {
 429   return (MumbleProto__UserRemove *)
 430      protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
 431                                 allocator, len, data);
 432 }
 433 void   mumble_proto__user_remove__free_unpacked
 434                      (MumbleProto__UserRemove *message,
 435                       ProtobufCAllocator *allocator)
 436 {
 437   assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
 438   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 439 }
 440 void   mumble_proto__user_state__init
 441                      (MumbleProto__UserState         *message)
 442 {
 443   static MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
 444   *message = init_value;
 445 }
 446 size_t mumble_proto__user_state__get_packed_size
 447                      (const MumbleProto__UserState *message)
 448 {
 449   assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
 450   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 451 }
 452 size_t mumble_proto__user_state__pack
 453                      (const MumbleProto__UserState *message,
 454                       uint8_t       *out)
 455 {
 456   assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
 457   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 458 }
 459 size_t mumble_proto__user_state__pack_to_buffer
 460                      (const MumbleProto__UserState *message,
 461                       ProtobufCBuffer *buffer)
 462 {
 463   assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
 464   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 465 }
 466 MumbleProto__UserState *
 467        mumble_proto__user_state__unpack
 468                      (ProtobufCAllocator  *allocator,
 469                       size_t               len,
 470                       const uint8_t       *data)
 471 {
 472   return (MumbleProto__UserState *)
 473      protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
 474                                 allocator, len, data);
 475 }
 476 void   mumble_proto__user_state__free_unpacked
 477                      (MumbleProto__UserState *message,
 478                       ProtobufCAllocator *allocator)
 479 {
 480   assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
 481   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 482 }
 483 void   mumble_proto__ban_list__ban_entry__init
 484                      (MumbleProto__BanList__BanEntry         *message)
 485 {
 486   static MumbleProto__BanList__BanEntry init_value = MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT;
 487   *message = init_value;
 488 }
 489 void   mumble_proto__ban_list__init
 490                      (MumbleProto__BanList         *message)
 491 {
 492   static MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
 493   *message = init_value;
 494 }
 495 size_t mumble_proto__ban_list__get_packed_size
 496                      (const MumbleProto__BanList *message)
 497 {
 498   assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
 499   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 500 }
 501 size_t mumble_proto__ban_list__pack
 502                      (const MumbleProto__BanList *message,
 503                       uint8_t       *out)
 504 {
 505   assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
 506   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 507 }
 508 size_t mumble_proto__ban_list__pack_to_buffer
 509                      (const MumbleProto__BanList *message,
 510                       ProtobufCBuffer *buffer)
 511 {
 512   assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
 513   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 514 }
 515 MumbleProto__BanList *
 516        mumble_proto__ban_list__unpack
 517                      (ProtobufCAllocator  *allocator,
 518                       size_t               len,
 519                       const uint8_t       *data)
 520 {
 521   return (MumbleProto__BanList *)
 522      protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
 523                                 allocator, len, data);
 524 }
 525 void   mumble_proto__ban_list__free_unpacked
 526                      (MumbleProto__BanList *message,
 527                       ProtobufCAllocator *allocator)
 528 {
 529   assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
 530   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 531 }
 532 void   mumble_proto__text_message__init
 533                      (MumbleProto__TextMessage         *message)
 534 {
 535   static MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
 536   *message = init_value;
 537 }
 538 size_t mumble_proto__text_message__get_packed_size
 539                      (const MumbleProto__TextMessage *message)
 540 {
 541   assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
 542   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 543 }
 544 size_t mumble_proto__text_message__pack
 545                      (const MumbleProto__TextMessage *message,
 546                       uint8_t       *out)
 547 {
 548   assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
 549   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 550 }
 551 size_t mumble_proto__text_message__pack_to_buffer
 552                      (const MumbleProto__TextMessage *message,
 553                       ProtobufCBuffer *buffer)
 554 {
 555   assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
 556   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 557 }
 558 MumbleProto__TextMessage *
 559        mumble_proto__text_message__unpack
 560                      (ProtobufCAllocator  *allocator,
 561                       size_t               len,
 562                       const uint8_t       *data)
 563 {
 564   return (MumbleProto__TextMessage *)
 565      protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
 566                                 allocator, len, data);
 567 }
 568 void   mumble_proto__text_message__free_unpacked
 569                      (MumbleProto__TextMessage *message,
 570                       ProtobufCAllocator *allocator)
 571 {
 572   assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
 573   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 574 }
 575 void   mumble_proto__permission_denied__init
 576                      (MumbleProto__PermissionDenied         *message)
 577 {
 578   static MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
 579   *message = init_value;
 580 }
 581 size_t mumble_proto__permission_denied__get_packed_size
 582                      (const MumbleProto__PermissionDenied *message)
 583 {
 584   assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 585   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 586 }
 587 size_t mumble_proto__permission_denied__pack
 588                      (const MumbleProto__PermissionDenied *message,
 589                       uint8_t       *out)
 590 {
 591   assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 592   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 593 }
 594 size_t mumble_proto__permission_denied__pack_to_buffer
 595                      (const MumbleProto__PermissionDenied *message,
 596                       ProtobufCBuffer *buffer)
 597 {
 598   assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 599   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 600 }
 601 MumbleProto__PermissionDenied *
 602        mumble_proto__permission_denied__unpack
 603                      (ProtobufCAllocator  *allocator,
 604                       size_t               len,
 605                       const uint8_t       *data)
 606 {
 607   return (MumbleProto__PermissionDenied *)
 608      protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
 609                                 allocator, len, data);
 610 }
 611 void   mumble_proto__permission_denied__free_unpacked
 612                      (MumbleProto__PermissionDenied *message,
 613                       ProtobufCAllocator *allocator)
 614 {
 615   assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 616   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 617 }
 618 void   mumble_proto__acl__chan_group__init
 619                      (MumbleProto__ACL__ChanGroup         *message)
 620 {
 621   static MumbleProto__ACL__ChanGroup init_value = MUMBLE_PROTO__ACL__CHAN_GROUP__INIT;
 622   *message = init_value;
 623 }
 624 void   mumble_proto__acl__chan_acl__init
 625                      (MumbleProto__ACL__ChanACL         *message)
 626 {
 627   static MumbleProto__ACL__ChanACL init_value = MUMBLE_PROTO__ACL__CHAN_ACL__INIT;
 628   *message = init_value;
 629 }
 630 void   mumble_proto__acl__init
 631                      (MumbleProto__ACL         *message)
 632 {
 633   static MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
 634   *message = init_value;
 635 }
 636 size_t mumble_proto__acl__get_packed_size
 637                      (const MumbleProto__ACL *message)
 638 {
 639   assert(message->base.descriptor == &mumble_proto__acl__descriptor);
 640   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 641 }
 642 size_t mumble_proto__acl__pack
 643                      (const MumbleProto__ACL *message,
 644                       uint8_t       *out)
 645 {
 646   assert(message->base.descriptor == &mumble_proto__acl__descriptor);
 647   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 648 }
 649 size_t mumble_proto__acl__pack_to_buffer
 650                      (const MumbleProto__ACL *message,
 651                       ProtobufCBuffer *buffer)
 652 {
 653   assert(message->base.descriptor == &mumble_proto__acl__descriptor);
 654   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 655 }
 656 MumbleProto__ACL *
 657        mumble_proto__acl__unpack
 658                      (ProtobufCAllocator  *allocator,
 659                       size_t               len,
 660                       const uint8_t       *data)
 661 {
 662   return (MumbleProto__ACL *)
 663      protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
 664                                 allocator, len, data);
 665 }
 666 void   mumble_proto__acl__free_unpacked
 667                      (MumbleProto__ACL *message,
 668                       ProtobufCAllocator *allocator)
 669 {
 670   assert(message->base.descriptor == &mumble_proto__acl__descriptor);
 671   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 672 }
 673 void   mumble_proto__query_users__init
 674                      (MumbleProto__QueryUsers         *message)
 675 {
 676   static MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
 677   *message = init_value;
 678 }
 679 size_t mumble_proto__query_users__get_packed_size
 680                      (const MumbleProto__QueryUsers *message)
 681 {
 682   assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
 683   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 684 }
 685 size_t mumble_proto__query_users__pack
 686                      (const MumbleProto__QueryUsers *message,
 687                       uint8_t       *out)
 688 {
 689   assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
 690   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 691 }
 692 size_t mumble_proto__query_users__pack_to_buffer
 693                      (const MumbleProto__QueryUsers *message,
 694                       ProtobufCBuffer *buffer)
 695 {
 696   assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
 697   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 698 }
 699 MumbleProto__QueryUsers *
 700        mumble_proto__query_users__unpack
 701                      (ProtobufCAllocator  *allocator,
 702                       size_t               len,
 703                       const uint8_t       *data)
 704 {
 705   return (MumbleProto__QueryUsers *)
 706      protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
 707                                 allocator, len, data);
 708 }
 709 void   mumble_proto__query_users__free_unpacked
 710                      (MumbleProto__QueryUsers *message,
 711                       ProtobufCAllocator *allocator)
 712 {
 713   assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
 714   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 715 }
 716 void   mumble_proto__crypt_setup__init
 717                      (MumbleProto__CryptSetup         *message)
 718 {
 719   static MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
 720   *message = init_value;
 721 }
 722 size_t mumble_proto__crypt_setup__get_packed_size
 723                      (const MumbleProto__CryptSetup *message)
 724 {
 725   assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 726   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 727 }
 728 size_t mumble_proto__crypt_setup__pack
 729                      (const MumbleProto__CryptSetup *message,
 730                       uint8_t       *out)
 731 {
 732   assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 733   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 734 }
 735 size_t mumble_proto__crypt_setup__pack_to_buffer
 736                      (const MumbleProto__CryptSetup *message,
 737                       ProtobufCBuffer *buffer)
 738 {
 739   assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 740   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 741 }
 742 MumbleProto__CryptSetup *
 743        mumble_proto__crypt_setup__unpack
 744                      (ProtobufCAllocator  *allocator,
 745                       size_t               len,
 746                       const uint8_t       *data)
 747 {
 748   return (MumbleProto__CryptSetup *)
 749      protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
 750                                 allocator, len, data);
 751 }
 752 void   mumble_proto__crypt_setup__free_unpacked
 753                      (MumbleProto__CryptSetup *message,
 754                       ProtobufCAllocator *allocator)
 755 {
 756   assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 757   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 758 }
 759 void   mumble_proto__context_action_modify__init
 760                      (MumbleProto__ContextActionModify         *message)
 761 {
 762   static MumbleProto__ContextActionModify init_value = MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT;
 763   *message = init_value;
 764 }
 765 size_t mumble_proto__context_action_modify__get_packed_size
 766                      (const MumbleProto__ContextActionModify *message)
 767 {
 768   assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 769   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 770 }
 771 size_t mumble_proto__context_action_modify__pack
 772                      (const MumbleProto__ContextActionModify *message,
 773                       uint8_t       *out)
 774 {
 775   assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 776   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 777 }
 778 size_t mumble_proto__context_action_modify__pack_to_buffer
 779                      (const MumbleProto__ContextActionModify *message,
 780                       ProtobufCBuffer *buffer)
 781 {
 782   assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 783   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 784 }
 785 MumbleProto__ContextActionModify *
 786        mumble_proto__context_action_modify__unpack
 787                      (ProtobufCAllocator  *allocator,
 788                       size_t               len,
 789                       const uint8_t       *data)
 790 {
 791   return (MumbleProto__ContextActionModify *)
 792      protobuf_c_message_unpack (&mumble_proto__context_action_modify__descriptor,
 793                                 allocator, len, data);
 794 }
 795 void   mumble_proto__context_action_modify__free_unpacked
 796                      (MumbleProto__ContextActionModify *message,
 797                       ProtobufCAllocator *allocator)
 798 {
 799   assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 800   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 801 }
 802 void   mumble_proto__context_action__init
 803                      (MumbleProto__ContextAction         *message)
 804 {
 805   static MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
 806   *message = init_value;
 807 }
 808 size_t mumble_proto__context_action__get_packed_size
 809                      (const MumbleProto__ContextAction *message)
 810 {
 811   assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
 812   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 813 }
 814 size_t mumble_proto__context_action__pack
 815                      (const MumbleProto__ContextAction *message,
 816                       uint8_t       *out)
 817 {
 818   assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
 819   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 820 }
 821 size_t mumble_proto__context_action__pack_to_buffer
 822                      (const MumbleProto__ContextAction *message,
 823                       ProtobufCBuffer *buffer)
 824 {
 825   assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
 826   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 827 }
 828 MumbleProto__ContextAction *
 829        mumble_proto__context_action__unpack
 830                      (ProtobufCAllocator  *allocator,
 831                       size_t               len,
 832                       const uint8_t       *data)
 833 {
 834   return (MumbleProto__ContextAction *)
 835      protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
 836                                 allocator, len, data);
 837 }
 838 void   mumble_proto__context_action__free_unpacked
 839                      (MumbleProto__ContextAction *message,
 840                       ProtobufCAllocator *allocator)
 841 {
 842   assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
 843   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 844 }
 845 void   mumble_proto__user_list__user__init
 846                      (MumbleProto__UserList__User         *message)
 847 {
 848   static MumbleProto__UserList__User init_value = MUMBLE_PROTO__USER_LIST__USER__INIT;
 849   *message = init_value;
 850 }
 851 void   mumble_proto__user_list__init
 852                      (MumbleProto__UserList         *message)
 853 {
 854   static MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
 855   *message = init_value;
 856 }
 857 size_t mumble_proto__user_list__get_packed_size
 858                      (const MumbleProto__UserList *message)
 859 {
 860   assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
 861   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 862 }
 863 size_t mumble_proto__user_list__pack
 864                      (const MumbleProto__UserList *message,
 865                       uint8_t       *out)
 866 {
 867   assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
 868   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 869 }
 870 size_t mumble_proto__user_list__pack_to_buffer
 871                      (const MumbleProto__UserList *message,
 872                       ProtobufCBuffer *buffer)
 873 {
 874   assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
 875   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 876 }
 877 MumbleProto__UserList *
 878        mumble_proto__user_list__unpack
 879                      (ProtobufCAllocator  *allocator,
 880                       size_t               len,
 881                       const uint8_t       *data)
 882 {
 883   return (MumbleProto__UserList *)
 884      protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
 885                                 allocator, len, data);
 886 }
 887 void   mumble_proto__user_list__free_unpacked
 888                      (MumbleProto__UserList *message,
 889                       ProtobufCAllocator *allocator)
 890 {
 891   assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
 892   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 893 }
 894 void   mumble_proto__voice_target__target__init
 895                      (MumbleProto__VoiceTarget__Target         *message)
 896 {
 897   static MumbleProto__VoiceTarget__Target init_value = MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT;
 898   *message = init_value;
 899 }
 900 void   mumble_proto__voice_target__init
 901                      (MumbleProto__VoiceTarget         *message)
 902 {
 903   static MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
 904   *message = init_value;
 905 }
 906 size_t mumble_proto__voice_target__get_packed_size
 907                      (const MumbleProto__VoiceTarget *message)
 908 {
 909   assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
 910   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 911 }
 912 size_t mumble_proto__voice_target__pack
 913                      (const MumbleProto__VoiceTarget *message,
 914                       uint8_t       *out)
 915 {
 916   assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
 917   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 918 }
 919 size_t mumble_proto__voice_target__pack_to_buffer
 920                      (const MumbleProto__VoiceTarget *message,
 921                       ProtobufCBuffer *buffer)
 922 {
 923   assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
 924   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 925 }
 926 MumbleProto__VoiceTarget *
 927        mumble_proto__voice_target__unpack
 928                      (ProtobufCAllocator  *allocator,
 929                       size_t               len,
 930                       const uint8_t       *data)
 931 {
 932   return (MumbleProto__VoiceTarget *)
 933      protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
 934                                 allocator, len, data);
 935 }
 936 void   mumble_proto__voice_target__free_unpacked
 937                      (MumbleProto__VoiceTarget *message,
 938                       ProtobufCAllocator *allocator)
 939 {
 940   assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
 941   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 942 }
 943 void   mumble_proto__permission_query__init
 944                      (MumbleProto__PermissionQuery         *message)
 945 {
 946   static MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
 947   *message = init_value;
 948 }
 949 size_t mumble_proto__permission_query__get_packed_size
 950                      (const MumbleProto__PermissionQuery *message)
 951 {
 952   assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
 953   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 954 }
 955 size_t mumble_proto__permission_query__pack
 956                      (const MumbleProto__PermissionQuery *message,
 957                       uint8_t       *out)
 958 {
 959   assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
 960   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 961 }
 962 size_t mumble_proto__permission_query__pack_to_buffer
 963                      (const MumbleProto__PermissionQuery *message,
 964                       ProtobufCBuffer *buffer)
 965 {
 966   assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
 967   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 968 }
 969 MumbleProto__PermissionQuery *
 970        mumble_proto__permission_query__unpack
 971                      (ProtobufCAllocator  *allocator,
 972                       size_t               len,
 973                       const uint8_t       *data)
 974 {
 975   return (MumbleProto__PermissionQuery *)
 976      protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
 977                                 allocator, len, data);
 978 }
 979 void   mumble_proto__permission_query__free_unpacked
 980                      (MumbleProto__PermissionQuery *message,
 981                       ProtobufCAllocator *allocator)
 982 {
 983   assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
 984   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 985 }
 986 void   mumble_proto__codec_version__init
 987                      (MumbleProto__CodecVersion         *message)
 988 {
 989   static MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
 990   *message = init_value;
 991 }
 992 size_t mumble_proto__codec_version__get_packed_size
 993                      (const MumbleProto__CodecVersion *message)
 994 {
 995   assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
 996   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 997 }
 998 size_t mumble_proto__codec_version__pack
 999                      (const MumbleProto__CodecVersion *message,
1000                       uint8_t       *out)
1001 {
1002   assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1003   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1004 }
1005 size_t mumble_proto__codec_version__pack_to_buffer
1006                      (const MumbleProto__CodecVersion *message,
1007                       ProtobufCBuffer *buffer)
1008 {
1009   assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1010   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1011 }
1012 MumbleProto__CodecVersion *
1013        mumble_proto__codec_version__unpack
1014                      (ProtobufCAllocator  *allocator,
1015                       size_t               len,
1016                       const uint8_t       *data)
1017 {
1018   return (MumbleProto__CodecVersion *)
1019      protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
1020                                 allocator, len, data);
1021 }
1022 void   mumble_proto__codec_version__free_unpacked
1023                      (MumbleProto__CodecVersion *message,
1024                       ProtobufCAllocator *allocator)
1025 {
1026   assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1027   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1028 }
1029 void   mumble_proto__user_stats__stats__init
1030                      (MumbleProto__UserStats__Stats         *message)
1031 {
1032   static MumbleProto__UserStats__Stats init_value = MUMBLE_PROTO__USER_STATS__STATS__INIT;
1033   *message = init_value;
1034 }
1035 void   mumble_proto__user_stats__init
1036                      (MumbleProto__UserStats         *message)
1037 {
1038   static MumbleProto__UserStats init_value = MUMBLE_PROTO__USER_STATS__INIT;
1039   *message = init_value;
1040 }
1041 size_t mumble_proto__user_stats__get_packed_size
1042                      (const MumbleProto__UserStats *message)
1043 {
1044   assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1045   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1046 }
1047 size_t mumble_proto__user_stats__pack
1048                      (const MumbleProto__UserStats *message,
1049                       uint8_t       *out)
1050 {
1051   assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1052   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1053 }
1054 size_t mumble_proto__user_stats__pack_to_buffer
1055                      (const MumbleProto__UserStats *message,
1056                       ProtobufCBuffer *buffer)
1057 {
1058   assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1059   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1060 }
1061 MumbleProto__UserStats *
1062        mumble_proto__user_stats__unpack
1063                      (ProtobufCAllocator  *allocator,
1064                       size_t               len,
1065                       const uint8_t       *data)
1066 {
1067   return (MumbleProto__UserStats *)
1068      protobuf_c_message_unpack (&mumble_proto__user_stats__descriptor,
1069                                 allocator, len, data);
1070 }
1071 void   mumble_proto__user_stats__free_unpacked
1072                      (MumbleProto__UserStats *message,
1073                       ProtobufCAllocator *allocator)
1074 {
1075   assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1076   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1077 }
1078 void   mumble_proto__suggest_config__init
1079                      (MumbleProto__SuggestConfig         *message)
1080 {
1081   static MumbleProto__SuggestConfig init_value = MUMBLE_PROTO__SUGGEST_CONFIG__INIT;
1082   *message = init_value;
1083 }
1084 size_t mumble_proto__suggest_config__get_packed_size
1085                      (const MumbleProto__SuggestConfig *message)
1086 {
1087   assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1088   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1089 }
1090 size_t mumble_proto__suggest_config__pack
1091                      (const MumbleProto__SuggestConfig *message,
1092                       uint8_t       *out)
1093 {
1094   assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1095   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1096 }
1097 size_t mumble_proto__suggest_config__pack_to_buffer
1098                      (const MumbleProto__SuggestConfig *message,
1099                       ProtobufCBuffer *buffer)
1100 {
1101   assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1102   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1103 }
1104 MumbleProto__SuggestConfig *
1105        mumble_proto__suggest_config__unpack
1106                      (ProtobufCAllocator  *allocator,
1107                       size_t               len,
1108                       const uint8_t       *data)
1109 {
1110   return (MumbleProto__SuggestConfig *)
1111      protobuf_c_message_unpack (&mumble_proto__suggest_config__descriptor,
1112                                 allocator, len, data);
1113 }
1114 void   mumble_proto__suggest_config__free_unpacked
1115                      (MumbleProto__SuggestConfig *message,
1116                       ProtobufCAllocator *allocator)
1117 {
1118   assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1119   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1120 }
1121 void   mumble_proto__request_blob__init
1122                      (MumbleProto__RequestBlob         *message)
1123 {
1124   static MumbleProto__RequestBlob init_value = MUMBLE_PROTO__REQUEST_BLOB__INIT;
1125   *message = init_value;
1126 }
1127 size_t mumble_proto__request_blob__get_packed_size
1128                      (const MumbleProto__RequestBlob *message)
1129 {
1130   assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1131   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1132 }
1133 size_t mumble_proto__request_blob__pack
1134                      (const MumbleProto__RequestBlob *message,
1135                       uint8_t       *out)
1136 {
1137   assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1138   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1139 }
1140 size_t mumble_proto__request_blob__pack_to_buffer
1141                      (const MumbleProto__RequestBlob *message,
1142                       ProtobufCBuffer *buffer)
1143 {
1144   assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1145   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1146 }
1147 MumbleProto__RequestBlob *
1148        mumble_proto__request_blob__unpack
1149                      (ProtobufCAllocator  *allocator,
1150                       size_t               len,
1151                       const uint8_t       *data)
1152 {
1153   return (MumbleProto__RequestBlob *)
1154      protobuf_c_message_unpack (&mumble_proto__request_blob__descriptor,
1155                                 allocator, len, data);
1156 }
1157 void   mumble_proto__request_blob__free_unpacked
1158                      (MumbleProto__RequestBlob *message,
1159                       ProtobufCAllocator *allocator)
1160 {
1161   assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1162   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1163 }
1164 static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
1165 {
1166   {
1167     "version",
1168     1,
1169     PROTOBUF_C_LABEL_OPTIONAL,
1170     PROTOBUF_C_TYPE_UINT32,
1171     offsetof(MumbleProto__Version, has_version),
1172     offsetof(MumbleProto__Version, version),
1173     NULL,
1174     NULL,
1175     0,             /* flags */
1176     0,NULL,NULL    /* reserved1,reserved2, etc */
1177   },
1178   {
1179     "release",
1180     2,
1181     PROTOBUF_C_LABEL_OPTIONAL,
1182     PROTOBUF_C_TYPE_STRING,
1183     0,   /* quantifier_offset */
1184     offsetof(MumbleProto__Version, release),
1185     NULL,
1186     NULL,
1187     0,             /* flags */
1188     0,NULL,NULL    /* reserved1,reserved2, etc */
1189   },
1190   {
1191     "os",
1192     3,
1193     PROTOBUF_C_LABEL_OPTIONAL,
1194     PROTOBUF_C_TYPE_STRING,
1195     0,   /* quantifier_offset */
1196     offsetof(MumbleProto__Version, os),
1197     NULL,
1198     NULL,
1199     0,             /* flags */
1200     0,NULL,NULL    /* reserved1,reserved2, etc */
1201   },
1202   {
1203     "os_version",
1204     4,
1205     PROTOBUF_C_LABEL_OPTIONAL,
1206     PROTOBUF_C_TYPE_STRING,
1207     0,   /* quantifier_offset */
1208     offsetof(MumbleProto__Version, os_version),
1209     NULL,
1210     NULL,
1211     0,             /* flags */
1212     0,NULL,NULL    /* reserved1,reserved2, etc */
1213   },
1214 };
1215 static const unsigned mumble_proto__version__field_indices_by_name[] = {
1216   2,   /* field[2] = os */
1217   3,   /* field[3] = os_version */
1218   1,   /* field[1] = release */
1219   0,   /* field[0] = version */
1220 };
1221 static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
1222 {
1223   { 1, 0 },
1224   { 0, 4 }
1225 };
1226 const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
1227 {
1228   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1229   "MumbleProto.Version",
1230   "Version",
1231   "MumbleProto__Version",
1232   "MumbleProto",
1233   sizeof(MumbleProto__Version),
1234   4,
1235   mumble_proto__version__field_descriptors,
1236   mumble_proto__version__field_indices_by_name,
1237   1,  mumble_proto__version__number_ranges,
1238   (ProtobufCMessageInit) mumble_proto__version__init,
1239   NULL,NULL,NULL    /* reserved[123] */
1240 };
1241 static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
1242 {
1243   {
1244     "packet",
1245     1,
1246     PROTOBUF_C_LABEL_REQUIRED,
1247     PROTOBUF_C_TYPE_BYTES,
1248     0,   /* quantifier_offset */
1249     offsetof(MumbleProto__UDPTunnel, packet),
1250     NULL,
1251     NULL,
1252     0,             /* flags */
1253     0,NULL,NULL    /* reserved1,reserved2, etc */
1254   },
1255 };
1256 static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
1257   0,   /* field[0] = packet */
1258 };
1259 static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
1260 {
1261   { 1, 0 },
1262   { 0, 1 }
1263 };
1264 const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
1265 {
1266   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1267   "MumbleProto.UDPTunnel",
1268   "UDPTunnel",
1269   "MumbleProto__UDPTunnel",
1270   "MumbleProto",
1271   sizeof(MumbleProto__UDPTunnel),
1272   1,
1273   mumble_proto__udptunnel__field_descriptors,
1274   mumble_proto__udptunnel__field_indices_by_name,
1275   1,  mumble_proto__udptunnel__number_ranges,
1276   (ProtobufCMessageInit) mumble_proto__udptunnel__init,
1277   NULL,NULL,NULL    /* reserved[123] */
1278 };
1279 static const protobuf_c_boolean mumble_proto__authenticate__opus__default_value = 0;
1280 static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[5] =
1281 {
1282   {
1283     "username",
1284     1,
1285     PROTOBUF_C_LABEL_OPTIONAL,
1286     PROTOBUF_C_TYPE_STRING,
1287     0,   /* quantifier_offset */
1288     offsetof(MumbleProto__Authenticate, username),
1289     NULL,
1290     NULL,
1291     0,             /* flags */
1292     0,NULL,NULL    /* reserved1,reserved2, etc */
1293   },
1294   {
1295     "password",
1296     2,
1297     PROTOBUF_C_LABEL_OPTIONAL,
1298     PROTOBUF_C_TYPE_STRING,
1299     0,   /* quantifier_offset */
1300     offsetof(MumbleProto__Authenticate, password),
1301     NULL,
1302     NULL,
1303     0,             /* flags */
1304     0,NULL,NULL    /* reserved1,reserved2, etc */
1305   },
1306   {
1307     "tokens",
1308     3,
1309     PROTOBUF_C_LABEL_REPEATED,
1310     PROTOBUF_C_TYPE_STRING,
1311     offsetof(MumbleProto__Authenticate, n_tokens),
1312     offsetof(MumbleProto__Authenticate, tokens),
1313     NULL,
1314     NULL,
1315     0,             /* flags */
1316     0,NULL,NULL    /* reserved1,reserved2, etc */
1317   },
1318   {
1319     "celt_versions",
1320     4,
1321     PROTOBUF_C_LABEL_REPEATED,
1322     PROTOBUF_C_TYPE_INT32,
1323     offsetof(MumbleProto__Authenticate, n_celt_versions),
1324     offsetof(MumbleProto__Authenticate, celt_versions),
1325     NULL,
1326     NULL,
1327     0,             /* flags */
1328     0,NULL,NULL    /* reserved1,reserved2, etc */
1329   },
1330   {
1331     "opus",
1332     5,
1333     PROTOBUF_C_LABEL_OPTIONAL,
1334     PROTOBUF_C_TYPE_BOOL,
1335     offsetof(MumbleProto__Authenticate, has_opus),
1336     offsetof(MumbleProto__Authenticate, opus),
1337     NULL,
1338     &mumble_proto__authenticate__opus__default_value,
1339     0,             /* flags */
1340     0,NULL,NULL    /* reserved1,reserved2, etc */
1341   },
1342 };
1343 static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
1344   3,   /* field[3] = celt_versions */
1345   4,   /* field[4] = opus */
1346   1,   /* field[1] = password */
1347   2,   /* field[2] = tokens */
1348   0,   /* field[0] = username */
1349 };
1350 static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
1351 {
1352   { 1, 0 },
1353   { 0, 5 }
1354 };
1355 const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
1356 {
1357   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1358   "MumbleProto.Authenticate",
1359   "Authenticate",
1360   "MumbleProto__Authenticate",
1361   "MumbleProto",
1362   sizeof(MumbleProto__Authenticate),
1363   5,
1364   mumble_proto__authenticate__field_descriptors,
1365   mumble_proto__authenticate__field_indices_by_name,
1366   1,  mumble_proto__authenticate__number_ranges,
1367   (ProtobufCMessageInit) mumble_proto__authenticate__init,
1368   NULL,NULL,NULL    /* reserved[123] */
1369 };
1370 static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
1371 {
1372   {
1373     "timestamp",
1374     1,
1375     PROTOBUF_C_LABEL_OPTIONAL,
1376     PROTOBUF_C_TYPE_UINT64,
1377     offsetof(MumbleProto__Ping, has_timestamp),
1378     offsetof(MumbleProto__Ping, timestamp),
1379     NULL,
1380     NULL,
1381     0,             /* flags */
1382     0,NULL,NULL    /* reserved1,reserved2, etc */
1383   },
1384   {
1385     "good",
1386     2,
1387     PROTOBUF_C_LABEL_OPTIONAL,
1388     PROTOBUF_C_TYPE_UINT32,
1389     offsetof(MumbleProto__Ping, has_good),
1390     offsetof(MumbleProto__Ping, good),
1391     NULL,
1392     NULL,
1393     0,             /* flags */
1394     0,NULL,NULL    /* reserved1,reserved2, etc */
1395   },
1396   {
1397     "late",
1398     3,
1399     PROTOBUF_C_LABEL_OPTIONAL,
1400     PROTOBUF_C_TYPE_UINT32,
1401     offsetof(MumbleProto__Ping, has_late),
1402     offsetof(MumbleProto__Ping, late),
1403     NULL,
1404     NULL,
1405     0,             /* flags */
1406     0,NULL,NULL    /* reserved1,reserved2, etc */
1407   },
1408   {
1409     "lost",
1410     4,
1411     PROTOBUF_C_LABEL_OPTIONAL,
1412     PROTOBUF_C_TYPE_UINT32,
1413     offsetof(MumbleProto__Ping, has_lost),
1414     offsetof(MumbleProto__Ping, lost),
1415     NULL,
1416     NULL,
1417     0,             /* flags */
1418     0,NULL,NULL    /* reserved1,reserved2, etc */
1419   },
1420   {
1421     "resync",
1422     5,
1423     PROTOBUF_C_LABEL_OPTIONAL,
1424     PROTOBUF_C_TYPE_UINT32,
1425     offsetof(MumbleProto__Ping, has_resync),
1426     offsetof(MumbleProto__Ping, resync),
1427     NULL,
1428     NULL,
1429     0,             /* flags */
1430     0,NULL,NULL    /* reserved1,reserved2, etc */
1431   },
1432   {
1433     "udp_packets",
1434     6,
1435     PROTOBUF_C_LABEL_OPTIONAL,
1436     PROTOBUF_C_TYPE_UINT32,
1437     offsetof(MumbleProto__Ping, has_udp_packets),
1438     offsetof(MumbleProto__Ping, udp_packets),
1439     NULL,
1440     NULL,
1441     0,             /* flags */
1442     0,NULL,NULL    /* reserved1,reserved2, etc */
1443   },
1444   {
1445     "tcp_packets",
1446     7,
1447     PROTOBUF_C_LABEL_OPTIONAL,
1448     PROTOBUF_C_TYPE_UINT32,
1449     offsetof(MumbleProto__Ping, has_tcp_packets),
1450     offsetof(MumbleProto__Ping, tcp_packets),
1451     NULL,
1452     NULL,
1453     0,             /* flags */
1454     0,NULL,NULL    /* reserved1,reserved2, etc */
1455   },
1456   {
1457     "udp_ping_avg",
1458     8,
1459     PROTOBUF_C_LABEL_OPTIONAL,
1460     PROTOBUF_C_TYPE_FLOAT,
1461     offsetof(MumbleProto__Ping, has_udp_ping_avg),
1462     offsetof(MumbleProto__Ping, udp_ping_avg),
1463     NULL,
1464     NULL,
1465     0,             /* flags */
1466     0,NULL,NULL    /* reserved1,reserved2, etc */
1467   },
1468   {
1469     "udp_ping_var",
1470     9,
1471     PROTOBUF_C_LABEL_OPTIONAL,
1472     PROTOBUF_C_TYPE_FLOAT,
1473     offsetof(MumbleProto__Ping, has_udp_ping_var),
1474     offsetof(MumbleProto__Ping, udp_ping_var),
1475     NULL,
1476     NULL,
1477     0,             /* flags */
1478     0,NULL,NULL    /* reserved1,reserved2, etc */
1479   },
1480   {
1481     "tcp_ping_avg",
1482     10,
1483     PROTOBUF_C_LABEL_OPTIONAL,
1484     PROTOBUF_C_TYPE_FLOAT,
1485     offsetof(MumbleProto__Ping, has_tcp_ping_avg),
1486     offsetof(MumbleProto__Ping, tcp_ping_avg),
1487     NULL,
1488     NULL,
1489     0,             /* flags */
1490     0,NULL,NULL    /* reserved1,reserved2, etc */
1491   },
1492   {
1493     "tcp_ping_var",
1494     11,
1495     PROTOBUF_C_LABEL_OPTIONAL,
1496     PROTOBUF_C_TYPE_FLOAT,
1497     offsetof(MumbleProto__Ping, has_tcp_ping_var),
1498     offsetof(MumbleProto__Ping, tcp_ping_var),
1499     NULL,
1500     NULL,
1501     0,             /* flags */
1502     0,NULL,NULL    /* reserved1,reserved2, etc */
1503   },
1504 };
1505 static const unsigned mumble_proto__ping__field_indices_by_name[] = {
1506   1,   /* field[1] = good */
1507   2,   /* field[2] = late */
1508   3,   /* field[3] = lost */
1509   4,   /* field[4] = resync */
1510   6,   /* field[6] = tcp_packets */
1511   9,   /* field[9] = tcp_ping_avg */
1512   10,   /* field[10] = tcp_ping_var */
1513   0,   /* field[0] = timestamp */
1514   5,   /* field[5] = udp_packets */
1515   7,   /* field[7] = udp_ping_avg */
1516   8,   /* field[8] = udp_ping_var */
1517 };
1518 static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
1519 {
1520   { 1, 0 },
1521   { 0, 11 }
1522 };
1523 const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
1524 {
1525   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1526   "MumbleProto.Ping",
1527   "Ping",
1528   "MumbleProto__Ping",
1529   "MumbleProto",
1530   sizeof(MumbleProto__Ping),
1531   11,
1532   mumble_proto__ping__field_descriptors,
1533   mumble_proto__ping__field_indices_by_name,
1534   1,  mumble_proto__ping__number_ranges,
1535   (ProtobufCMessageInit) mumble_proto__ping__init,
1536   NULL,NULL,NULL    /* reserved[123] */
1537 };
1538 const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
1539 {
1540   { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__None", 0 },
1541   { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion", 1 },
1542   { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername", 2 },
1543   { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW", 3 },
1544   { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW", 4 },
1545   { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse", 5 },
1546   { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull", 6 },
1547   { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate", 7 },
1548 };
1549 static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
1550 {0, 0},{0, 8}
1551 };
1552 const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
1553 {
1554   { "InvalidUsername", 2 },
1555   { "NoCertificate", 7 },
1556   { "None", 0 },
1557   { "ServerFull", 6 },
1558   { "UsernameInUse", 5 },
1559   { "WrongServerPW", 4 },
1560   { "WrongUserPW", 3 },
1561   { "WrongVersion", 1 },
1562 };
1563 const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
1564 {
1565   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
1566   "MumbleProto.Reject.RejectType",
1567   "RejectType",
1568   "MumbleProto__Reject__RejectType",
1569   "MumbleProto",
1570   8,
1571   mumble_proto__reject__reject_type__enum_values_by_number,
1572   8,
1573   mumble_proto__reject__reject_type__enum_values_by_name,
1574   1,
1575   mumble_proto__reject__reject_type__value_ranges,
1576   NULL,NULL,NULL,NULL   /* reserved[1234] */
1577 };
1578 static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
1579 {
1580   {
1581     "type",
1582     1,
1583     PROTOBUF_C_LABEL_OPTIONAL,
1584     PROTOBUF_C_TYPE_ENUM,
1585     offsetof(MumbleProto__Reject, has_type),
1586     offsetof(MumbleProto__Reject, type),
1587     &mumble_proto__reject__reject_type__descriptor,
1588     NULL,
1589     0,             /* flags */
1590     0,NULL,NULL    /* reserved1,reserved2, etc */
1591   },
1592   {
1593     "reason",
1594     2,
1595     PROTOBUF_C_LABEL_OPTIONAL,
1596     PROTOBUF_C_TYPE_STRING,
1597     0,   /* quantifier_offset */
1598     offsetof(MumbleProto__Reject, reason),
1599     NULL,
1600     NULL,
1601     0,             /* flags */
1602     0,NULL,NULL    /* reserved1,reserved2, etc */
1603   },
1604 };
1605 static const unsigned mumble_proto__reject__field_indices_by_name[] = {
1606   1,   /* field[1] = reason */
1607   0,   /* field[0] = type */
1608 };
1609 static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
1610 {
1611   { 1, 0 },
1612   { 0, 2 }
1613 };
1614 const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
1615 {
1616   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1617   "MumbleProto.Reject",
1618   "Reject",
1619   "MumbleProto__Reject",
1620   "MumbleProto",
1621   sizeof(MumbleProto__Reject),
1622   2,
1623   mumble_proto__reject__field_descriptors,
1624   mumble_proto__reject__field_indices_by_name,
1625   1,  mumble_proto__reject__number_ranges,
1626   (ProtobufCMessageInit) mumble_proto__reject__init,
1627   NULL,NULL,NULL    /* reserved[123] */
1628 };
1629 static const ProtobufCFieldDescriptor mumble_proto__server_config__field_descriptors[5] =
1630 {
1631   {
1632     "max_bandwidth",
1633     1,
1634     PROTOBUF_C_LABEL_OPTIONAL,
1635     PROTOBUF_C_TYPE_UINT32,
1636     offsetof(MumbleProto__ServerConfig, has_max_bandwidth),
1637     offsetof(MumbleProto__ServerConfig, max_bandwidth),
1638     NULL,
1639     NULL,
1640     0,             /* flags */
1641     0,NULL,NULL    /* reserved1,reserved2, etc */
1642   },
1643   {
1644     "welcome_text",
1645     2,
1646     PROTOBUF_C_LABEL_OPTIONAL,
1647     PROTOBUF_C_TYPE_STRING,
1648     0,   /* quantifier_offset */
1649     offsetof(MumbleProto__ServerConfig, welcome_text),
1650     NULL,
1651     NULL,
1652     0,             /* flags */
1653     0,NULL,NULL    /* reserved1,reserved2, etc */
1654   },
1655   {
1656     "allow_html",
1657     3,
1658     PROTOBUF_C_LABEL_OPTIONAL,
1659     PROTOBUF_C_TYPE_BOOL,
1660     offsetof(MumbleProto__ServerConfig, has_allow_html),
1661     offsetof(MumbleProto__ServerConfig, allow_html),
1662     NULL,
1663     NULL,
1664     0,             /* flags */
1665     0,NULL,NULL    /* reserved1,reserved2, etc */
1666   },
1667   {
1668     "message_length",
1669     4,
1670     PROTOBUF_C_LABEL_OPTIONAL,
1671     PROTOBUF_C_TYPE_UINT32,
1672     offsetof(MumbleProto__ServerConfig, has_message_length),
1673     offsetof(MumbleProto__ServerConfig, message_length),
1674     NULL,
1675     NULL,
1676     0,             /* flags */
1677     0,NULL,NULL    /* reserved1,reserved2, etc */
1678   },
1679   {
1680     "image_message_length",
1681     5,
1682     PROTOBUF_C_LABEL_OPTIONAL,
1683     PROTOBUF_C_TYPE_UINT32,
1684     offsetof(MumbleProto__ServerConfig, has_image_message_length),
1685     offsetof(MumbleProto__ServerConfig, image_message_length),
1686     NULL,
1687     NULL,
1688     0,             /* flags */
1689     0,NULL,NULL    /* reserved1,reserved2, etc */
1690   },
1691 };
1692 static const unsigned mumble_proto__server_config__field_indices_by_name[] = {
1693   2,   /* field[2] = allow_html */
1694   4,   /* field[4] = image_message_length */
1695   0,   /* field[0] = max_bandwidth */
1696   3,   /* field[3] = message_length */
1697   1,   /* field[1] = welcome_text */
1698 };
1699 static const ProtobufCIntRange mumble_proto__server_config__number_ranges[1 + 1] =
1700 {
1701   { 1, 0 },
1702   { 0, 5 }
1703 };
1704 const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor =
1705 {
1706   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1707   "MumbleProto.ServerConfig",
1708   "ServerConfig",
1709   "MumbleProto__ServerConfig",
1710   "MumbleProto",
1711   sizeof(MumbleProto__ServerConfig),
1712   5,
1713   mumble_proto__server_config__field_descriptors,
1714   mumble_proto__server_config__field_indices_by_name,
1715   1,  mumble_proto__server_config__number_ranges,
1716   (ProtobufCMessageInit) mumble_proto__server_config__init,
1717   NULL,NULL,NULL    /* reserved[123] */
1718 };
1719 static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[4] =
1720 {
1721   {
1722     "session",
1723     1,
1724     PROTOBUF_C_LABEL_OPTIONAL,
1725     PROTOBUF_C_TYPE_UINT32,
1726     offsetof(MumbleProto__ServerSync, has_session),
1727     offsetof(MumbleProto__ServerSync, session),
1728     NULL,
1729     NULL,
1730     0,             /* flags */
1731     0,NULL,NULL    /* reserved1,reserved2, etc */
1732   },
1733   {
1734     "max_bandwidth",
1735     2,
1736     PROTOBUF_C_LABEL_OPTIONAL,
1737     PROTOBUF_C_TYPE_UINT32,
1738     offsetof(MumbleProto__ServerSync, has_max_bandwidth),
1739     offsetof(MumbleProto__ServerSync, max_bandwidth),
1740     NULL,
1741     NULL,
1742     0,             /* flags */
1743     0,NULL,NULL    /* reserved1,reserved2, etc */
1744   },
1745   {
1746     "welcome_text",
1747     3,
1748     PROTOBUF_C_LABEL_OPTIONAL,
1749     PROTOBUF_C_TYPE_STRING,
1750     0,   /* quantifier_offset */
1751     offsetof(MumbleProto__ServerSync, welcome_text),
1752     NULL,
1753     NULL,
1754     0,             /* flags */
1755     0,NULL,NULL    /* reserved1,reserved2, etc */
1756   },
1757   {
1758     "permissions",
1759     4,
1760     PROTOBUF_C_LABEL_OPTIONAL,
1761     PROTOBUF_C_TYPE_UINT64,
1762     offsetof(MumbleProto__ServerSync, has_permissions),
1763     offsetof(MumbleProto__ServerSync, permissions),
1764     NULL,
1765     NULL,
1766     0,             /* flags */
1767     0,NULL,NULL    /* reserved1,reserved2, etc */
1768   },
1769 };
1770 static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
1771   1,   /* field[1] = max_bandwidth */
1772   3,   /* field[3] = permissions */
1773   0,   /* field[0] = session */
1774   2,   /* field[2] = welcome_text */
1775 };
1776 static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
1777 {
1778   { 1, 0 },
1779   { 0, 4 }
1780 };
1781 const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
1782 {
1783   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1784   "MumbleProto.ServerSync",
1785   "ServerSync",
1786   "MumbleProto__ServerSync",
1787   "MumbleProto",
1788   sizeof(MumbleProto__ServerSync),
1789   4,
1790   mumble_proto__server_sync__field_descriptors,
1791   mumble_proto__server_sync__field_indices_by_name,
1792   1,  mumble_proto__server_sync__number_ranges,
1793   (ProtobufCMessageInit) mumble_proto__server_sync__init,
1794   NULL,NULL,NULL    /* reserved[123] */
1795 };
1796 static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
1797 {
1798   {
1799     "channel_id",
1800     1,
1801     PROTOBUF_C_LABEL_REQUIRED,
1802     PROTOBUF_C_TYPE_UINT32,
1803     0,   /* quantifier_offset */
1804     offsetof(MumbleProto__ChannelRemove, channel_id),
1805     NULL,
1806     NULL,
1807     0,             /* flags */
1808     0,NULL,NULL    /* reserved1,reserved2, etc */
1809   },
1810 };
1811 static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
1812   0,   /* field[0] = channel_id */
1813 };
1814 static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
1815 {
1816   { 1, 0 },
1817   { 0, 1 }
1818 };
1819 const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
1820 {
1821   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1822   "MumbleProto.ChannelRemove",
1823   "ChannelRemove",
1824   "MumbleProto__ChannelRemove",
1825   "MumbleProto",
1826   sizeof(MumbleProto__ChannelRemove),
1827   1,
1828   mumble_proto__channel_remove__field_descriptors,
1829   mumble_proto__channel_remove__field_indices_by_name,
1830   1,  mumble_proto__channel_remove__number_ranges,
1831   (ProtobufCMessageInit) mumble_proto__channel_remove__init,
1832   NULL,NULL,NULL    /* reserved[123] */
1833 };
1834 static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
1835 static const int32_t mumble_proto__channel_state__position__default_value = 0;
1836 static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[10] =
1837 {
1838   {
1839     "channel_id",
1840     1,
1841     PROTOBUF_C_LABEL_OPTIONAL,
1842     PROTOBUF_C_TYPE_UINT32,
1843     offsetof(MumbleProto__ChannelState, has_channel_id),
1844     offsetof(MumbleProto__ChannelState, channel_id),
1845     NULL,
1846     NULL,
1847     0,             /* flags */
1848     0,NULL,NULL    /* reserved1,reserved2, etc */
1849   },
1850   {
1851     "parent",
1852     2,
1853     PROTOBUF_C_LABEL_OPTIONAL,
1854     PROTOBUF_C_TYPE_UINT32,
1855     offsetof(MumbleProto__ChannelState, has_parent),
1856     offsetof(MumbleProto__ChannelState, parent),
1857     NULL,
1858     NULL,
1859     0,             /* flags */
1860     0,NULL,NULL    /* reserved1,reserved2, etc */
1861   },
1862   {
1863     "name",
1864     3,
1865     PROTOBUF_C_LABEL_OPTIONAL,
1866     PROTOBUF_C_TYPE_STRING,
1867     0,   /* quantifier_offset */
1868     offsetof(MumbleProto__ChannelState, name),
1869     NULL,
1870     NULL,
1871     0,             /* flags */
1872     0,NULL,NULL    /* reserved1,reserved2, etc */
1873   },
1874   {
1875     "links",
1876     4,
1877     PROTOBUF_C_LABEL_REPEATED,
1878     PROTOBUF_C_TYPE_UINT32,
1879     offsetof(MumbleProto__ChannelState, n_links),
1880     offsetof(MumbleProto__ChannelState, links),
1881     NULL,
1882     NULL,
1883     0,             /* flags */
1884     0,NULL,NULL    /* reserved1,reserved2, etc */
1885   },
1886   {
1887     "description",
1888     5,
1889     PROTOBUF_C_LABEL_OPTIONAL,
1890     PROTOBUF_C_TYPE_STRING,
1891     0,   /* quantifier_offset */
1892     offsetof(MumbleProto__ChannelState, description),
1893     NULL,
1894     NULL,
1895     0,             /* flags */
1896     0,NULL,NULL    /* reserved1,reserved2, etc */
1897   },
1898   {
1899     "links_add",
1900     6,
1901     PROTOBUF_C_LABEL_REPEATED,
1902     PROTOBUF_C_TYPE_UINT32,
1903     offsetof(MumbleProto__ChannelState, n_links_add),
1904     offsetof(MumbleProto__ChannelState, links_add),
1905     NULL,
1906     NULL,
1907     0,             /* flags */
1908     0,NULL,NULL    /* reserved1,reserved2, etc */
1909   },
1910   {
1911     "links_remove",
1912     7,
1913     PROTOBUF_C_LABEL_REPEATED,
1914     PROTOBUF_C_TYPE_UINT32,
1915     offsetof(MumbleProto__ChannelState, n_links_remove),
1916     offsetof(MumbleProto__ChannelState, links_remove),
1917     NULL,
1918     NULL,
1919     0,             /* flags */
1920     0,NULL,NULL    /* reserved1,reserved2, etc */
1921   },
1922   {
1923     "temporary",
1924     8,
1925     PROTOBUF_C_LABEL_OPTIONAL,
1926     PROTOBUF_C_TYPE_BOOL,
1927     offsetof(MumbleProto__ChannelState, has_temporary),
1928     offsetof(MumbleProto__ChannelState, temporary),
1929     NULL,
1930     &mumble_proto__channel_state__temporary__default_value,
1931     0,             /* flags */
1932     0,NULL,NULL    /* reserved1,reserved2, etc */
1933   },
1934   {
1935     "position",
1936     9,
1937     PROTOBUF_C_LABEL_OPTIONAL,
1938     PROTOBUF_C_TYPE_INT32,
1939     offsetof(MumbleProto__ChannelState, has_position),
1940     offsetof(MumbleProto__ChannelState, position),
1941     NULL,
1942     &mumble_proto__channel_state__position__default_value,
1943     0,             /* flags */
1944     0,NULL,NULL    /* reserved1,reserved2, etc */
1945   },
1946   {
1947     "description_hash",
1948     10,
1949     PROTOBUF_C_LABEL_OPTIONAL,
1950     PROTOBUF_C_TYPE_BYTES,
1951     offsetof(MumbleProto__ChannelState, has_description_hash),
1952     offsetof(MumbleProto__ChannelState, description_hash),
1953     NULL,
1954     NULL,
1955     0,             /* flags */
1956     0,NULL,NULL    /* reserved1,reserved2, etc */
1957   },
1958 };
1959 static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
1960   0,   /* field[0] = channel_id */
1961   4,   /* field[4] = description */
1962   9,   /* field[9] = description_hash */
1963   3,   /* field[3] = links */
1964   5,   /* field[5] = links_add */
1965   6,   /* field[6] = links_remove */
1966   2,   /* field[2] = name */
1967   1,   /* field[1] = parent */
1968   8,   /* field[8] = position */
1969   7,   /* field[7] = temporary */
1970 };
1971 static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
1972 {
1973   { 1, 0 },
1974   { 0, 10 }
1975 };
1976 const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
1977 {
1978   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1979   "MumbleProto.ChannelState",
1980   "ChannelState",
1981   "MumbleProto__ChannelState",
1982   "MumbleProto",
1983   sizeof(MumbleProto__ChannelState),
1984   10,
1985   mumble_proto__channel_state__field_descriptors,
1986   mumble_proto__channel_state__field_indices_by_name,
1987   1,  mumble_proto__channel_state__number_ranges,
1988   (ProtobufCMessageInit) mumble_proto__channel_state__init,
1989   NULL,NULL,NULL    /* reserved[123] */
1990 };
1991 static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
1992 {
1993   {
1994     "session",
1995     1,
1996     PROTOBUF_C_LABEL_REQUIRED,
1997     PROTOBUF_C_TYPE_UINT32,
1998     0,   /* quantifier_offset */
1999     offsetof(MumbleProto__UserRemove, session),
2000     NULL,
2001     NULL,
2002     0,             /* flags */
2003     0,NULL,NULL    /* reserved1,reserved2, etc */
2004   },
2005   {
2006     "actor",
2007     2,
2008     PROTOBUF_C_LABEL_OPTIONAL,
2009     PROTOBUF_C_TYPE_UINT32,
2010     offsetof(MumbleProto__UserRemove, has_actor),
2011     offsetof(MumbleProto__UserRemove, actor),
2012     NULL,
2013     NULL,
2014     0,             /* flags */
2015     0,NULL,NULL    /* reserved1,reserved2, etc */
2016   },
2017   {
2018     "reason",
2019     3,
2020     PROTOBUF_C_LABEL_OPTIONAL,
2021     PROTOBUF_C_TYPE_STRING,
2022     0,   /* quantifier_offset */
2023     offsetof(MumbleProto__UserRemove, reason),
2024     NULL,
2025     NULL,
2026     0,             /* flags */
2027     0,NULL,NULL    /* reserved1,reserved2, etc */
2028   },
2029   {
2030     "ban",
2031     4,
2032     PROTOBUF_C_LABEL_OPTIONAL,
2033     PROTOBUF_C_TYPE_BOOL,
2034     offsetof(MumbleProto__UserRemove, has_ban),
2035     offsetof(MumbleProto__UserRemove, ban),
2036     NULL,
2037     NULL,
2038     0,             /* flags */
2039     0,NULL,NULL    /* reserved1,reserved2, etc */
2040   },
2041 };
2042 static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
2043   1,   /* field[1] = actor */
2044   3,   /* field[3] = ban */
2045   2,   /* field[2] = reason */
2046   0,   /* field[0] = session */
2047 };
2048 static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
2049 {
2050   { 1, 0 },
2051   { 0, 4 }
2052 };
2053 const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
2054 {
2055   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2056   "MumbleProto.UserRemove",
2057   "UserRemove",
2058   "MumbleProto__UserRemove",
2059   "MumbleProto",
2060   sizeof(MumbleProto__UserRemove),
2061   4,
2062   mumble_proto__user_remove__field_descriptors,
2063   mumble_proto__user_remove__field_indices_by_name,
2064   1,  mumble_proto__user_remove__number_ranges,
2065   (ProtobufCMessageInit) mumble_proto__user_remove__init,
2066   NULL,NULL,NULL    /* reserved[123] */
2067 };
2068 static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[19] =
2069 {
2070   {
2071     "session",
2072     1,
2073     PROTOBUF_C_LABEL_OPTIONAL,
2074     PROTOBUF_C_TYPE_UINT32,
2075     offsetof(MumbleProto__UserState, has_session),
2076     offsetof(MumbleProto__UserState, session),
2077     NULL,
2078     NULL,
2079     0,             /* flags */
2080     0,NULL,NULL    /* reserved1,reserved2, etc */
2081   },
2082   {
2083     "actor",
2084     2,
2085     PROTOBUF_C_LABEL_OPTIONAL,
2086     PROTOBUF_C_TYPE_UINT32,
2087     offsetof(MumbleProto__UserState, has_actor),
2088     offsetof(MumbleProto__UserState, actor),
2089     NULL,
2090     NULL,
2091     0,             /* flags */
2092     0,NULL,NULL    /* reserved1,reserved2, etc */
2093   },
2094   {
2095     "name",
2096     3,
2097     PROTOBUF_C_LABEL_OPTIONAL,
2098     PROTOBUF_C_TYPE_STRING,
2099     0,   /* quantifier_offset */
2100     offsetof(MumbleProto__UserState, name),
2101     NULL,
2102     NULL,
2103     0,             /* flags */
2104     0,NULL,NULL    /* reserved1,reserved2, etc */
2105   },
2106   {
2107     "user_id",
2108     4,
2109     PROTOBUF_C_LABEL_OPTIONAL,
2110     PROTOBUF_C_TYPE_UINT32,
2111     offsetof(MumbleProto__UserState, has_user_id),
2112     offsetof(MumbleProto__UserState, user_id),
2113     NULL,
2114     NULL,
2115     0,             /* flags */
2116     0,NULL,NULL    /* reserved1,reserved2, etc */
2117   },
2118   {
2119     "channel_id",
2120     5,
2121     PROTOBUF_C_LABEL_OPTIONAL,
2122     PROTOBUF_C_TYPE_UINT32,
2123     offsetof(MumbleProto__UserState, has_channel_id),
2124     offsetof(MumbleProto__UserState, channel_id),
2125     NULL,
2126     NULL,
2127     0,             /* flags */
2128     0,NULL,NULL    /* reserved1,reserved2, etc */
2129   },
2130   {
2131     "mute",
2132     6,
2133     PROTOBUF_C_LABEL_OPTIONAL,
2134     PROTOBUF_C_TYPE_BOOL,
2135     offsetof(MumbleProto__UserState, has_mute),
2136     offsetof(MumbleProto__UserState, mute),
2137     NULL,
2138     NULL,
2139     0,             /* flags */
2140     0,NULL,NULL    /* reserved1,reserved2, etc */
2141   },
2142   {
2143     "deaf",
2144     7,
2145     PROTOBUF_C_LABEL_OPTIONAL,
2146     PROTOBUF_C_TYPE_BOOL,
2147     offsetof(MumbleProto__UserState, has_deaf),
2148     offsetof(MumbleProto__UserState, deaf),
2149     NULL,
2150     NULL,
2151     0,             /* flags */
2152     0,NULL,NULL    /* reserved1,reserved2, etc */
2153   },
2154   {
2155     "suppress",
2156     8,
2157     PROTOBUF_C_LABEL_OPTIONAL,
2158     PROTOBUF_C_TYPE_BOOL,
2159     offsetof(MumbleProto__UserState, has_suppress),
2160     offsetof(MumbleProto__UserState, suppress),
2161     NULL,
2162     NULL,
2163     0,             /* flags */
2164     0,NULL,NULL    /* reserved1,reserved2, etc */
2165   },
2166   {
2167     "self_mute",
2168     9,
2169     PROTOBUF_C_LABEL_OPTIONAL,
2170     PROTOBUF_C_TYPE_BOOL,
2171     offsetof(MumbleProto__UserState, has_self_mute),
2172     offsetof(MumbleProto__UserState, self_mute),
2173     NULL,
2174     NULL,
2175     0,             /* flags */
2176     0,NULL,NULL    /* reserved1,reserved2, etc */
2177   },
2178   {
2179     "self_deaf",
2180     10,
2181     PROTOBUF_C_LABEL_OPTIONAL,
2182     PROTOBUF_C_TYPE_BOOL,
2183     offsetof(MumbleProto__UserState, has_self_deaf),
2184     offsetof(MumbleProto__UserState, self_deaf),
2185     NULL,
2186     NULL,
2187     0,             /* flags */
2188     0,NULL,NULL    /* reserved1,reserved2, etc */
2189   },
2190   {
2191     "texture",
2192     11,
2193     PROTOBUF_C_LABEL_OPTIONAL,
2194     PROTOBUF_C_TYPE_BYTES,
2195     offsetof(MumbleProto__UserState, has_texture),
2196     offsetof(MumbleProto__UserState, texture),
2197     NULL,
2198     NULL,
2199     0,             /* flags */
2200     0,NULL,NULL    /* reserved1,reserved2, etc */
2201   },
2202   {
2203     "plugin_context",
2204     12,
2205     PROTOBUF_C_LABEL_OPTIONAL,
2206     PROTOBUF_C_TYPE_BYTES,
2207     offsetof(MumbleProto__UserState, has_plugin_context),
2208     offsetof(MumbleProto__UserState, plugin_context),
2209     NULL,
2210     NULL,
2211     0,             /* flags */
2212     0,NULL,NULL    /* reserved1,reserved2, etc */
2213   },
2214   {
2215     "plugin_identity",
2216     13,
2217     PROTOBUF_C_LABEL_OPTIONAL,
2218     PROTOBUF_C_TYPE_STRING,
2219     0,   /* quantifier_offset */
2220     offsetof(MumbleProto__UserState, plugin_identity),
2221     NULL,
2222     NULL,
2223     0,             /* flags */
2224     0,NULL,NULL    /* reserved1,reserved2, etc */
2225   },
2226   {
2227     "comment",
2228     14,
2229     PROTOBUF_C_LABEL_OPTIONAL,
2230     PROTOBUF_C_TYPE_STRING,
2231     0,   /* quantifier_offset */
2232     offsetof(MumbleProto__UserState, comment),
2233     NULL,
2234     NULL,
2235     0,             /* flags */
2236     0,NULL,NULL    /* reserved1,reserved2, etc */
2237   },
2238   {
2239     "hash",
2240     15,
2241     PROTOBUF_C_LABEL_OPTIONAL,
2242     PROTOBUF_C_TYPE_STRING,
2243     0,   /* quantifier_offset */
2244     offsetof(MumbleProto__UserState, hash),
2245     NULL,
2246     NULL,
2247     0,             /* flags */
2248     0,NULL,NULL    /* reserved1,reserved2, etc */
2249   },
2250   {
2251     "comment_hash",
2252     16,
2253     PROTOBUF_C_LABEL_OPTIONAL,
2254     PROTOBUF_C_TYPE_BYTES,
2255     offsetof(MumbleProto__UserState, has_comment_hash),
2256     offsetof(MumbleProto__UserState, comment_hash),
2257     NULL,
2258     NULL,
2259     0,             /* flags */
2260     0,NULL,NULL    /* reserved1,reserved2, etc */
2261   },
2262   {
2263     "texture_hash",
2264     17,
2265     PROTOBUF_C_LABEL_OPTIONAL,
2266     PROTOBUF_C_TYPE_BYTES,
2267     offsetof(MumbleProto__UserState, has_texture_hash),
2268     offsetof(MumbleProto__UserState, texture_hash),
2269     NULL,
2270     NULL,
2271     0,             /* flags */
2272     0,NULL,NULL    /* reserved1,reserved2, etc */
2273   },
2274   {
2275     "priority_speaker",
2276     18,
2277     PROTOBUF_C_LABEL_OPTIONAL,
2278     PROTOBUF_C_TYPE_BOOL,
2279     offsetof(MumbleProto__UserState, has_priority_speaker),
2280     offsetof(MumbleProto__UserState, priority_speaker),
2281     NULL,
2282     NULL,
2283     0,             /* flags */
2284     0,NULL,NULL    /* reserved1,reserved2, etc */
2285   },
2286   {
2287     "recording",
2288     19,
2289     PROTOBUF_C_LABEL_OPTIONAL,
2290     PROTOBUF_C_TYPE_BOOL,
2291     offsetof(MumbleProto__UserState, has_recording),
2292     offsetof(MumbleProto__UserState, recording),
2293     NULL,
2294     NULL,
2295     0,             /* flags */
2296     0,NULL,NULL    /* reserved1,reserved2, etc */
2297   },
2298 };
2299 static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
2300   1,   /* field[1] = actor */
2301   4,   /* field[4] = channel_id */
2302   13,   /* field[13] = comment */
2303   15,   /* field[15] = comment_hash */
2304   6,   /* field[6] = deaf */
2305   14,   /* field[14] = hash */
2306   5,   /* field[5] = mute */
2307   2,   /* field[2] = name */
2308   11,   /* field[11] = plugin_context */
2309   12,   /* field[12] = plugin_identity */
2310   17,   /* field[17] = priority_speaker */
2311   18,   /* field[18] = recording */
2312   9,   /* field[9] = self_deaf */
2313   8,   /* field[8] = self_mute */
2314   0,   /* field[0] = session */
2315   7,   /* field[7] = suppress */
2316   10,   /* field[10] = texture */
2317   16,   /* field[16] = texture_hash */
2318   3,   /* field[3] = user_id */
2319 };
2320 static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
2321 {
2322   { 1, 0 },
2323   { 0, 19 }
2324 };
2325 const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
2326 {
2327   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2328   "MumbleProto.UserState",
2329   "UserState",
2330   "MumbleProto__UserState",
2331   "MumbleProto",
2332   sizeof(MumbleProto__UserState),
2333   19,
2334   mumble_proto__user_state__field_descriptors,
2335   mumble_proto__user_state__field_indices_by_name,
2336   1,  mumble_proto__user_state__number_ranges,
2337   (ProtobufCMessageInit) mumble_proto__user_state__init,
2338   NULL,NULL,NULL    /* reserved[123] */
2339 };
2340 static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
2341 {
2342   {
2343     "address",
2344     1,
2345     PROTOBUF_C_LABEL_REQUIRED,
2346     PROTOBUF_C_TYPE_BYTES,
2347     0,   /* quantifier_offset */
2348     offsetof(MumbleProto__BanList__BanEntry, address),
2349     NULL,
2350     NULL,
2351     0,             /* flags */
2352     0,NULL,NULL    /* reserved1,reserved2, etc */
2353   },
2354   {
2355     "mask",
2356     2,
2357     PROTOBUF_C_LABEL_REQUIRED,
2358     PROTOBUF_C_TYPE_UINT32,
2359     0,   /* quantifier_offset */
2360     offsetof(MumbleProto__BanList__BanEntry, mask),
2361     NULL,
2362     NULL,
2363     0,             /* flags */
2364     0,NULL,NULL    /* reserved1,reserved2, etc */
2365   },
2366   {
2367     "name",
2368     3,
2369     PROTOBUF_C_LABEL_OPTIONAL,
2370     PROTOBUF_C_TYPE_STRING,
2371     0,   /* quantifier_offset */
2372     offsetof(MumbleProto__BanList__BanEntry, name),
2373     NULL,
2374     NULL,
2375     0,             /* flags */
2376     0,NULL,NULL    /* reserved1,reserved2, etc */
2377   },
2378   {
2379     "hash",
2380     4,
2381     PROTOBUF_C_LABEL_OPTIONAL,
2382     PROTOBUF_C_TYPE_STRING,
2383     0,   /* quantifier_offset */
2384     offsetof(MumbleProto__BanList__BanEntry, hash),
2385     NULL,
2386     NULL,
2387     0,             /* flags */
2388     0,NULL,NULL    /* reserved1,reserved2, etc */
2389   },
2390   {
2391     "reason",
2392     5,
2393     PROTOBUF_C_LABEL_OPTIONAL,
2394     PROTOBUF_C_TYPE_STRING,
2395     0,   /* quantifier_offset */
2396     offsetof(MumbleProto__BanList__BanEntry, reason),
2397     NULL,
2398     NULL,
2399     0,             /* flags */
2400     0,NULL,NULL    /* reserved1,reserved2, etc */
2401   },
2402   {
2403     "start",
2404     6,
2405     PROTOBUF_C_LABEL_OPTIONAL,
2406     PROTOBUF_C_TYPE_STRING,
2407     0,   /* quantifier_offset */
2408     offsetof(MumbleProto__BanList__BanEntry, start),
2409     NULL,
2410     NULL,
2411     0,             /* flags */
2412     0,NULL,NULL    /* reserved1,reserved2, etc */
2413   },
2414   {
2415     "duration",
2416     7,
2417     PROTOBUF_C_LABEL_OPTIONAL,
2418     PROTOBUF_C_TYPE_UINT32,
2419     offsetof(MumbleProto__BanList__BanEntry, has_duration),
2420     offsetof(MumbleProto__BanList__BanEntry, duration),
2421     NULL,
2422     NULL,
2423     0,             /* flags */
2424     0,NULL,NULL    /* reserved1,reserved2, etc */
2425   },
2426 };
2427 static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
2428   0,   /* field[0] = address */
2429   6,   /* field[6] = duration */
2430   3,   /* field[3] = hash */
2431   1,   /* field[1] = mask */
2432   2,   /* field[2] = name */
2433   4,   /* field[4] = reason */
2434   5,   /* field[5] = start */
2435 };
2436 static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
2437 {
2438   { 1, 0 },
2439   { 0, 7 }
2440 };
2441 const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
2442 {
2443   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2444   "MumbleProto.BanList.BanEntry",
2445   "BanEntry",
2446   "MumbleProto__BanList__BanEntry",
2447   "MumbleProto",
2448   sizeof(MumbleProto__BanList__BanEntry),
2449   7,
2450   mumble_proto__ban_list__ban_entry__field_descriptors,
2451   mumble_proto__ban_list__ban_entry__field_indices_by_name,
2452   1,  mumble_proto__ban_list__ban_entry__number_ranges,
2453   (ProtobufCMessageInit) mumble_proto__ban_list__ban_entry__init,
2454   NULL,NULL,NULL    /* reserved[123] */
2455 };
2456 static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
2457 static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
2458 {
2459   {
2460     "bans",
2461     1,
2462     PROTOBUF_C_LABEL_REPEATED,
2463     PROTOBUF_C_TYPE_MESSAGE,
2464     offsetof(MumbleProto__BanList, n_bans),
2465     offsetof(MumbleProto__BanList, bans),
2466     &mumble_proto__ban_list__ban_entry__descriptor,
2467     NULL,
2468     0,             /* flags */
2469     0,NULL,NULL    /* reserved1,reserved2, etc */
2470   },
2471   {
2472     "query",
2473     2,
2474     PROTOBUF_C_LABEL_OPTIONAL,
2475     PROTOBUF_C_TYPE_BOOL,
2476     offsetof(MumbleProto__BanList, has_query),
2477     offsetof(MumbleProto__BanList, query),
2478     NULL,
2479     &mumble_proto__ban_list__query__default_value,
2480     0,             /* flags */
2481     0,NULL,NULL    /* reserved1,reserved2, etc */
2482   },
2483 };
2484 static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
2485   0,   /* field[0] = bans */
2486   1,   /* field[1] = query */
2487 };
2488 static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
2489 {
2490   { 1, 0 },
2491   { 0, 2 }
2492 };
2493 const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
2494 {
2495   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2496   "MumbleProto.BanList",
2497   "BanList",
2498   "MumbleProto__BanList",
2499   "MumbleProto",
2500   sizeof(MumbleProto__BanList),
2501   2,
2502   mumble_proto__ban_list__field_descriptors,
2503   mumble_proto__ban_list__field_indices_by_name,
2504   1,  mumble_proto__ban_list__number_ranges,
2505   (ProtobufCMessageInit) mumble_proto__ban_list__init,
2506   NULL,NULL,NULL    /* reserved[123] */
2507 };
2508 static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
2509 {
2510   {
2511     "actor",
2512     1,
2513     PROTOBUF_C_LABEL_OPTIONAL,
2514     PROTOBUF_C_TYPE_UINT32,
2515     offsetof(MumbleProto__TextMessage, has_actor),
2516     offsetof(MumbleProto__TextMessage, actor),
2517     NULL,
2518     NULL,
2519     0,             /* flags */
2520     0,NULL,NULL    /* reserved1,reserved2, etc */
2521   },
2522   {
2523     "session",
2524     2,
2525     PROTOBUF_C_LABEL_REPEATED,
2526     PROTOBUF_C_TYPE_UINT32,
2527     offsetof(MumbleProto__TextMessage, n_session),
2528     offsetof(MumbleProto__TextMessage, session),
2529     NULL,
2530     NULL,
2531     0,             /* flags */
2532     0,NULL,NULL    /* reserved1,reserved2, etc */
2533   },
2534   {
2535     "channel_id",
2536     3,
2537     PROTOBUF_C_LABEL_REPEATED,
2538     PROTOBUF_C_TYPE_UINT32,
2539     offsetof(MumbleProto__TextMessage, n_channel_id),
2540     offsetof(MumbleProto__TextMessage, channel_id),
2541     NULL,
2542     NULL,
2543     0,             /* flags */
2544     0,NULL,NULL    /* reserved1,reserved2, etc */
2545   },
2546   {
2547     "tree_id",
2548     4,
2549     PROTOBUF_C_LABEL_REPEATED,
2550     PROTOBUF_C_TYPE_UINT32,
2551     offsetof(MumbleProto__TextMessage, n_tree_id),
2552     offsetof(MumbleProto__TextMessage, tree_id),
2553     NULL,
2554     NULL,
2555     0,             /* flags */
2556     0,NULL,NULL    /* reserved1,reserved2, etc */
2557   },
2558   {
2559     "message",
2560     5,
2561     PROTOBUF_C_LABEL_REQUIRED,
2562     PROTOBUF_C_TYPE_STRING,
2563     0,   /* quantifier_offset */
2564     offsetof(MumbleProto__TextMessage, message),
2565     NULL,
2566     NULL,
2567     0,             /* flags */
2568     0,NULL,NULL    /* reserved1,reserved2, etc */
2569   },
2570 };
2571 static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
2572   0,   /* field[0] = actor */
2573   2,   /* field[2] = channel_id */
2574   4,   /* field[4] = message */
2575   1,   /* field[1] = session */
2576   3,   /* field[3] = tree_id */
2577 };
2578 static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
2579 {
2580   { 1, 0 },
2581   { 0, 5 }
2582 };
2583 const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
2584 {
2585   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2586   "MumbleProto.TextMessage",
2587   "TextMessage",
2588   "MumbleProto__TextMessage",
2589   "MumbleProto",
2590   sizeof(MumbleProto__TextMessage),
2591   5,
2592   mumble_proto__text_message__field_descriptors,
2593   mumble_proto__text_message__field_indices_by_name,
2594   1,  mumble_proto__text_message__number_ranges,
2595   (ProtobufCMessageInit) mumble_proto__text_message__init,
2596   NULL,NULL,NULL    /* reserved[123] */
2597 };
2598 const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[11] =
2599 {
2600   { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text", 0 },
2601   { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission", 1 },
2602   { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser", 2 },
2603   { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName", 3 },
2604   { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong", 4 },
2605   { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
2606   { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel", 6 },
2607   { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate", 7 },
2608   { "UserName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName", 8 },
2609   { "ChannelFull", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull", 9 },
2610   { "NestingLimit", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NestingLimit", 10 },
2611 };
2612 static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
2613 {0, 0},{0, 11}
2614 };
2615 const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[11] =
2616 {
2617   { "ChannelFull", 9 },
2618   { "ChannelName", 3 },
2619   { "H9K", 5 },
2620   { "MissingCertificate", 7 },
2621   { "NestingLimit", 10 },
2622   { "Permission", 1 },
2623   { "SuperUser", 2 },
2624   { "TemporaryChannel", 6 },
2625   { "Text", 0 },
2626   { "TextTooLong", 4 },
2627   { "UserName", 8 },
2628 };
2629 const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
2630 {
2631   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2632   "MumbleProto.PermissionDenied.DenyType",
2633   "DenyType",
2634   "MumbleProto__PermissionDenied__DenyType",
2635   "MumbleProto",
2636   11,
2637   mumble_proto__permission_denied__deny_type__enum_values_by_number,
2638   11,
2639   mumble_proto__permission_denied__deny_type__enum_values_by_name,
2640   1,
2641   mumble_proto__permission_denied__deny_type__value_ranges,
2642   NULL,NULL,NULL,NULL   /* reserved[1234] */
2643 };
2644 static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[6] =
2645 {
2646   {
2647     "permission",
2648     1,
2649     PROTOBUF_C_LABEL_OPTIONAL,
2650     PROTOBUF_C_TYPE_UINT32,
2651     offsetof(MumbleProto__PermissionDenied, has_permission),
2652     offsetof(MumbleProto__PermissionDenied, permission),
2653     NULL,
2654     NULL,
2655     0,             /* flags */
2656     0,NULL,NULL    /* reserved1,reserved2, etc */
2657   },
2658   {
2659     "channel_id",
2660     2,
2661     PROTOBUF_C_LABEL_OPTIONAL,
2662     PROTOBUF_C_TYPE_UINT32,
2663     offsetof(MumbleProto__PermissionDenied, has_channel_id),
2664     offsetof(MumbleProto__PermissionDenied, channel_id),
2665     NULL,
2666     NULL,
2667     0,             /* flags */
2668     0,NULL,NULL    /* reserved1,reserved2, etc */
2669   },
2670   {
2671     "session",
2672     3,
2673     PROTOBUF_C_LABEL_OPTIONAL,
2674     PROTOBUF_C_TYPE_UINT32,
2675     offsetof(MumbleProto__PermissionDenied, has_session),
2676     offsetof(MumbleProto__PermissionDenied, session),
2677     NULL,
2678     NULL,
2679     0,             /* flags */
2680     0,NULL,NULL    /* reserved1,reserved2, etc */
2681   },
2682   {
2683     "reason",
2684     4,
2685     PROTOBUF_C_LABEL_OPTIONAL,
2686     PROTOBUF_C_TYPE_STRING,
2687     0,   /* quantifier_offset */
2688     offsetof(MumbleProto__PermissionDenied, reason),
2689     NULL,
2690     NULL,
2691     0,             /* flags */
2692     0,NULL,NULL    /* reserved1,reserved2, etc */
2693   },
2694   {
2695     "type",
2696     5,
2697     PROTOBUF_C_LABEL_OPTIONAL,
2698     PROTOBUF_C_TYPE_ENUM,
2699     offsetof(MumbleProto__PermissionDenied, has_type),
2700     offsetof(MumbleProto__PermissionDenied, type),
2701     &mumble_proto__permission_denied__deny_type__descriptor,
2702     NULL,
2703     0,             /* flags */
2704     0,NULL,NULL    /* reserved1,reserved2, etc */
2705   },
2706   {
2707     "name",
2708     6,
2709     PROTOBUF_C_LABEL_OPTIONAL,
2710     PROTOBUF_C_TYPE_STRING,
2711     0,   /* quantifier_offset */
2712     offsetof(MumbleProto__PermissionDenied, name),
2713     NULL,
2714     NULL,
2715     0,             /* flags */
2716     0,NULL,NULL    /* reserved1,reserved2, etc */
2717   },
2718 };
2719 static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
2720   1,   /* field[1] = channel_id */
2721   5,   /* field[5] = name */
2722   0,   /* field[0] = permission */
2723   3,   /* field[3] = reason */
2724   2,   /* field[2] = session */
2725   4,   /* field[4] = type */
2726 };
2727 static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
2728 {
2729   { 1, 0 },
2730   { 0, 6 }
2731 };
2732 const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
2733 {
2734   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2735   "MumbleProto.PermissionDenied",
2736   "PermissionDenied",
2737   "MumbleProto__PermissionDenied",
2738   "MumbleProto",
2739   sizeof(MumbleProto__PermissionDenied),
2740   6,
2741   mumble_proto__permission_denied__field_descriptors,
2742   mumble_proto__permission_denied__field_indices_by_name,
2743   1,  mumble_proto__permission_denied__number_ranges,
2744   (ProtobufCMessageInit) mumble_proto__permission_denied__init,
2745   NULL,NULL,NULL    /* reserved[123] */
2746 };
2747 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
2748 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
2749 static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
2750 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
2751 {
2752   {
2753     "name",
2754     1,
2755     PROTOBUF_C_LABEL_REQUIRED,
2756     PROTOBUF_C_TYPE_STRING,
2757     0,   /* quantifier_offset */
2758     offsetof(MumbleProto__ACL__ChanGroup, name),
2759     NULL,
2760     NULL,
2761     0,             /* flags */
2762     0,NULL,NULL    /* reserved1,reserved2, etc */
2763   },
2764   {
2765     "inherited",
2766     2,
2767     PROTOBUF_C_LABEL_OPTIONAL,
2768     PROTOBUF_C_TYPE_BOOL,
2769     offsetof(MumbleProto__ACL__ChanGroup, has_inherited),
2770     offsetof(MumbleProto__ACL__ChanGroup, inherited),
2771     NULL,
2772     &mumble_proto__acl__chan_group__inherited__default_value,
2773     0,             /* flags */
2774     0,NULL,NULL    /* reserved1,reserved2, etc */
2775   },
2776   {
2777     "inherit",
2778     3,
2779     PROTOBUF_C_LABEL_OPTIONAL,
2780     PROTOBUF_C_TYPE_BOOL,
2781     offsetof(MumbleProto__ACL__ChanGroup, has_inherit),
2782     offsetof(MumbleProto__ACL__ChanGroup, inherit),
2783     NULL,
2784     &mumble_proto__acl__chan_group__inherit__default_value,
2785     0,             /* flags */
2786     0,NULL,NULL    /* reserved1,reserved2, etc */
2787   },
2788   {
2789     "inheritable",
2790     4,
2791     PROTOBUF_C_LABEL_OPTIONAL,
2792     PROTOBUF_C_TYPE_BOOL,
2793     offsetof(MumbleProto__ACL__ChanGroup, has_inheritable),
2794     offsetof(MumbleProto__ACL__ChanGroup, inheritable),
2795     NULL,
2796     &mumble_proto__acl__chan_group__inheritable__default_value,
2797     0,             /* flags */
2798     0,NULL,NULL    /* reserved1,reserved2, etc */
2799   },
2800   {
2801     "add",
2802     5,
2803     PROTOBUF_C_LABEL_REPEATED,
2804     PROTOBUF_C_TYPE_UINT32,
2805     offsetof(MumbleProto__ACL__ChanGroup, n_add),
2806     offsetof(MumbleProto__ACL__ChanGroup, add),
2807     NULL,
2808     NULL,
2809     0,             /* flags */
2810     0,NULL,NULL    /* reserved1,reserved2, etc */
2811   },
2812   {
2813     "remove",
2814     6,
2815     PROTOBUF_C_LABEL_REPEATED,
2816     PROTOBUF_C_TYPE_UINT32,
2817     offsetof(MumbleProto__ACL__ChanGroup, n_remove),
2818     offsetof(MumbleProto__ACL__ChanGroup, remove),
2819     NULL,
2820     NULL,
2821     0,             /* flags */
2822     0,NULL,NULL    /* reserved1,reserved2, etc */
2823   },
2824   {
2825     "inherited_members",
2826     7,
2827     PROTOBUF_C_LABEL_REPEATED,
2828     PROTOBUF_C_TYPE_UINT32,
2829     offsetof(MumbleProto__ACL__ChanGroup, n_inherited_members),
2830     offsetof(MumbleProto__ACL__ChanGroup, inherited_members),
2831     NULL,
2832     NULL,
2833     0,             /* flags */
2834     0,NULL,NULL    /* reserved1,reserved2, etc */
2835   },
2836 };
2837 static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
2838   4,   /* field[4] = add */
2839   2,   /* field[2] = inherit */
2840   3,   /* field[3] = inheritable */
2841   1,   /* field[1] = inherited */
2842   6,   /* field[6] = inherited_members */
2843   0,   /* field[0] = name */
2844   5,   /* field[5] = remove */
2845 };
2846 static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
2847 {
2848   { 1, 0 },
2849   { 0, 7 }
2850 };
2851 const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
2852 {
2853   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2854   "MumbleProto.ACL.ChanGroup",
2855   "ChanGroup",
2856   "MumbleProto__ACL__ChanGroup",
2857   "MumbleProto",
2858   sizeof(MumbleProto__ACL__ChanGroup),
2859   7,
2860   mumble_proto__acl__chan_group__field_descriptors,
2861   mumble_proto__acl__chan_group__field_indices_by_name,
2862   1,  mumble_proto__acl__chan_group__number_ranges,
2863   (ProtobufCMessageInit) mumble_proto__acl__chan_group__init,
2864   NULL,NULL,NULL    /* reserved[123] */
2865 };
2866 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
2867 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
2868 static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
2869 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
2870 {
2871   {
2872     "apply_here",
2873     1,
2874     PROTOBUF_C_LABEL_OPTIONAL,
2875     PROTOBUF_C_TYPE_BOOL,
2876     offsetof(MumbleProto__ACL__ChanACL, has_apply_here),
2877     offsetof(MumbleProto__ACL__ChanACL, apply_here),
2878     NULL,
2879     &mumble_proto__acl__chan_acl__apply_here__default_value,
2880     0,             /* flags */
2881     0,NULL,NULL    /* reserved1,reserved2, etc */
2882   },
2883   {
2884     "apply_subs",
2885     2,
2886     PROTOBUF_C_LABEL_OPTIONAL,
2887     PROTOBUF_C_TYPE_BOOL,
2888     offsetof(MumbleProto__ACL__ChanACL, has_apply_subs),
2889     offsetof(MumbleProto__ACL__ChanACL, apply_subs),
2890     NULL,
2891     &mumble_proto__acl__chan_acl__apply_subs__default_value,
2892     0,             /* flags */
2893     0,NULL,NULL    /* reserved1,reserved2, etc */
2894   },
2895   {
2896     "inherited",
2897     3,
2898     PROTOBUF_C_LABEL_OPTIONAL,
2899     PROTOBUF_C_TYPE_BOOL,
2900     offsetof(MumbleProto__ACL__ChanACL, has_inherited),
2901     offsetof(MumbleProto__ACL__ChanACL, inherited),
2902     NULL,
2903     &mumble_proto__acl__chan_acl__inherited__default_value,
2904     0,             /* flags */
2905     0,NULL,NULL    /* reserved1,reserved2, etc */
2906   },
2907   {
2908     "user_id",
2909     4,
2910     PROTOBUF_C_LABEL_OPTIONAL,
2911     PROTOBUF_C_TYPE_UINT32,
2912     offsetof(MumbleProto__ACL__ChanACL, has_user_id),
2913     offsetof(MumbleProto__ACL__ChanACL, user_id),
2914     NULL,
2915     NULL,
2916     0,             /* flags */
2917     0,NULL,NULL    /* reserved1,reserved2, etc */
2918   },
2919   {
2920     "group",
2921     5,
2922     PROTOBUF_C_LABEL_OPTIONAL,
2923     PROTOBUF_C_TYPE_STRING,
2924     0,   /* quantifier_offset */
2925     offsetof(MumbleProto__ACL__ChanACL, group),
2926     NULL,
2927     NULL,
2928     0,             /* flags */
2929     0,NULL,NULL    /* reserved1,reserved2, etc */
2930   },
2931   {
2932     "grant",
2933     6,
2934     PROTOBUF_C_LABEL_OPTIONAL,
2935     PROTOBUF_C_TYPE_UINT32,
2936     offsetof(MumbleProto__ACL__ChanACL, has_grant),
2937     offsetof(MumbleProto__ACL__ChanACL, grant),
2938     NULL,
2939     NULL,
2940     0,             /* flags */
2941     0,NULL,NULL    /* reserved1,reserved2, etc */
2942   },
2943   {
2944     "deny",
2945     7,
2946     PROTOBUF_C_LABEL_OPTIONAL,
2947     PROTOBUF_C_TYPE_UINT32,
2948     offsetof(MumbleProto__ACL__ChanACL, has_deny),
2949     offsetof(MumbleProto__ACL__ChanACL, deny),
2950     NULL,
2951     NULL,
2952     0,             /* flags */
2953     0,NULL,NULL    /* reserved1,reserved2, etc */
2954   },
2955 };
2956 static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
2957   0,   /* field[0] = apply_here */
2958   1,   /* field[1] = apply_subs */
2959   6,   /* field[6] = deny */
2960   5,   /* field[5] = grant */
2961   4,   /* field[4] = group */
2962   2,   /* field[2] = inherited */
2963   3,   /* field[3] = user_id */
2964 };
2965 static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
2966 {
2967   { 1, 0 },
2968   { 0, 7 }
2969 };
2970 const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
2971 {
2972   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2973   "MumbleProto.ACL.ChanACL",
2974   "ChanACL",
2975   "MumbleProto__ACL__ChanACL",
2976   "MumbleProto",
2977   sizeof(MumbleProto__ACL__ChanACL),
2978   7,
2979   mumble_proto__acl__chan_acl__field_descriptors,
2980   mumble_proto__acl__chan_acl__field_indices_by_name,
2981   1,  mumble_proto__acl__chan_acl__number_ranges,
2982   (ProtobufCMessageInit) mumble_proto__acl__chan_acl__init,
2983   NULL,NULL,NULL    /* reserved[123] */
2984 };
2985 static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
2986 static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
2987 static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
2988 {
2989   {
2990     "channel_id",
2991     1,
2992     PROTOBUF_C_LABEL_REQUIRED,
2993     PROTOBUF_C_TYPE_UINT32,
2994     0,   /* quantifier_offset */
2995     offsetof(MumbleProto__ACL, channel_id),
2996     NULL,
2997     NULL,
2998     0,             /* flags */
2999     0,NULL,NULL    /* reserved1,reserved2, etc */
3000   },
3001   {
3002     "inherit_acls",
3003     2,
3004     PROTOBUF_C_LABEL_OPTIONAL,
3005     PROTOBUF_C_TYPE_BOOL,
3006     offsetof(MumbleProto__ACL, has_inherit_acls),
3007     offsetof(MumbleProto__ACL, inherit_acls),
3008     NULL,
3009     &mumble_proto__acl__inherit_acls__default_value,
3010     0,             /* flags */
3011     0,NULL,NULL    /* reserved1,reserved2, etc */
3012   },
3013   {
3014     "groups",
3015     3,
3016     PROTOBUF_C_LABEL_REPEATED,
3017     PROTOBUF_C_TYPE_MESSAGE,
3018     offsetof(MumbleProto__ACL, n_groups),
3019     offsetof(MumbleProto__ACL, groups),
3020     &mumble_proto__acl__chan_group__descriptor,
3021     NULL,
3022     0,             /* flags */
3023     0,NULL,NULL    /* reserved1,reserved2, etc */
3024   },
3025   {
3026     "acls",
3027     4,
3028     PROTOBUF_C_LABEL_REPEATED,
3029     PROTOBUF_C_TYPE_MESSAGE,
3030     offsetof(MumbleProto__ACL, n_acls),
3031     offsetof(MumbleProto__ACL, acls),
3032     &mumble_proto__acl__chan_acl__descriptor,
3033     NULL,
3034     0,             /* flags */
3035     0,NULL,NULL    /* reserved1,reserved2, etc */
3036   },
3037   {
3038     "query",
3039     5,
3040     PROTOBUF_C_LABEL_OPTIONAL,
3041     PROTOBUF_C_TYPE_BOOL,
3042     offsetof(MumbleProto__ACL, has_query),
3043     offsetof(MumbleProto__ACL, query),
3044     NULL,
3045     &mumble_proto__acl__query__default_value,
3046     0,             /* flags */
3047     0,NULL,NULL    /* reserved1,reserved2, etc */
3048   },
3049 };
3050 static const unsigned mumble_proto__acl__field_indices_by_name[] = {
3051   3,   /* field[3] = acls */
3052   0,   /* field[0] = channel_id */
3053   2,   /* field[2] = groups */
3054   1,   /* field[1] = inherit_acls */
3055   4,   /* field[4] = query */
3056 };
3057 static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
3058 {
3059   { 1, 0 },
3060   { 0, 5 }
3061 };
3062 const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
3063 {
3064   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3065   "MumbleProto.ACL",
3066   "ACL",
3067   "MumbleProto__ACL",
3068   "MumbleProto",
3069   sizeof(MumbleProto__ACL),
3070   5,
3071   mumble_proto__acl__field_descriptors,
3072   mumble_proto__acl__field_indices_by_name,
3073   1,  mumble_proto__acl__number_ranges,
3074   (ProtobufCMessageInit) mumble_proto__acl__init,
3075   NULL,NULL,NULL    /* reserved[123] */
3076 };
3077 static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
3078 {
3079   {
3080     "ids",
3081     1,
3082     PROTOBUF_C_LABEL_REPEATED,
3083     PROTOBUF_C_TYPE_UINT32,
3084     offsetof(MumbleProto__QueryUsers, n_ids),
3085     offsetof(MumbleProto__QueryUsers, ids),
3086     NULL,
3087     NULL,
3088     0,             /* flags */
3089     0,NULL,NULL    /* reserved1,reserved2, etc */
3090   },
3091   {
3092     "names",
3093     2,
3094     PROTOBUF_C_LABEL_REPEATED,
3095     PROTOBUF_C_TYPE_STRING,
3096     offsetof(MumbleProto__QueryUsers, n_names),
3097     offsetof(MumbleProto__QueryUsers, names),
3098     NULL,
3099     NULL,
3100     0,             /* flags */
3101     0,NULL,NULL    /* reserved1,reserved2, etc */
3102   },
3103 };
3104 static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
3105   0,   /* field[0] = ids */
3106   1,   /* field[1] = names */
3107 };
3108 static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
3109 {
3110   { 1, 0 },
3111   { 0, 2 }
3112 };
3113 const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
3114 {
3115   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3116   "MumbleProto.QueryUsers",
3117   "QueryUsers",
3118   "MumbleProto__QueryUsers",
3119   "MumbleProto",
3120   sizeof(MumbleProto__QueryUsers),
3121   2,
3122   mumble_proto__query_users__field_descriptors,
3123   mumble_proto__query_users__field_indices_by_name,
3124   1,  mumble_proto__query_users__number_ranges,
3125   (ProtobufCMessageInit) mumble_proto__query_users__init,
3126   NULL,NULL,NULL    /* reserved[123] */
3127 };
3128 static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
3129 {
3130   {
3131     "key",
3132     1,
3133     PROTOBUF_C_LABEL_OPTIONAL,
3134     PROTOBUF_C_TYPE_BYTES,
3135     offsetof(MumbleProto__CryptSetup, has_key),
3136     offsetof(MumbleProto__CryptSetup, key),
3137     NULL,
3138     NULL,
3139     0,             /* flags */
3140     0,NULL,NULL    /* reserved1,reserved2, etc */
3141   },
3142   {
3143     "client_nonce",
3144     2,
3145     PROTOBUF_C_LABEL_OPTIONAL,
3146     PROTOBUF_C_TYPE_BYTES,
3147     offsetof(MumbleProto__CryptSetup, has_client_nonce),
3148     offsetof(MumbleProto__CryptSetup, client_nonce),
3149     NULL,
3150     NULL,
3151     0,             /* flags */
3152     0,NULL,NULL    /* reserved1,reserved2, etc */
3153   },
3154   {
3155     "server_nonce",
3156     3,
3157     PROTOBUF_C_LABEL_OPTIONAL,
3158     PROTOBUF_C_TYPE_BYTES,
3159     offsetof(MumbleProto__CryptSetup, has_server_nonce),
3160     offsetof(MumbleProto__CryptSetup, server_nonce),
3161     NULL,
3162     NULL,
3163     0,             /* flags */
3164     0,NULL,NULL    /* reserved1,reserved2, etc */
3165   },
3166 };
3167 static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
3168   1,   /* field[1] = client_nonce */
3169   0,   /* field[0] = key */
3170   2,   /* field[2] = server_nonce */
3171 };
3172 static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
3173 {
3174   { 1, 0 },
3175   { 0, 3 }
3176 };
3177 const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
3178 {
3179   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3180   "MumbleProto.CryptSetup",
3181   "CryptSetup",
3182   "MumbleProto__CryptSetup",
3183   "MumbleProto",
3184   sizeof(MumbleProto__CryptSetup),
3185   3,
3186   mumble_proto__crypt_setup__field_descriptors,
3187   mumble_proto__crypt_setup__field_indices_by_name,
3188   1,  mumble_proto__crypt_setup__number_ranges,
3189   (ProtobufCMessageInit) mumble_proto__crypt_setup__init,
3190   NULL,NULL,NULL    /* reserved[123] */
3191 };
3192 const ProtobufCEnumValue mumble_proto__context_action_modify__context__enum_values_by_number[3] =
3193 {
3194   { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Server", 1 },
3195   { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Channel", 2 },
3196   { "User", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__User", 4 },
3197 };
3198 static const ProtobufCIntRange mumble_proto__context_action_modify__context__value_ranges[] = {
3199 {1, 0},{4, 2},{0, 3}
3200 };
3201 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__context__enum_values_by_name[3] =
3202 {
3203   { "Channel", 1 },
3204   { "Server", 0 },
3205   { "User", 2 },
3206 };
3207 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__context__descriptor =
3208 {
3209   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3210   "MumbleProto.ContextActionModify.Context",
3211   "Context",
3212   "MumbleProto__ContextActionModify__Context",
3213   "MumbleProto",
3214   3,
3215   mumble_proto__context_action_modify__context__enum_values_by_number,
3216   3,
3217   mumble_proto__context_action_modify__context__enum_values_by_name,
3218   2,
3219   mumble_proto__context_action_modify__context__value_ranges,
3220   NULL,NULL,NULL,NULL   /* reserved[1234] */
3221 };
3222 const ProtobufCEnumValue mumble_proto__context_action_modify__operation__enum_values_by_number[2] =
3223 {
3224   { "Add", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add", 0 },
3225   { "Remove", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Remove", 1 },
3226 };
3227 static const ProtobufCIntRange mumble_proto__context_action_modify__operation__value_ranges[] = {
3228 {0, 0},{0, 2}
3229 };
3230 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__operation__enum_values_by_name[2] =
3231 {
3232   { "Add", 0 },
3233   { "Remove", 1 },
3234 };
3235 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__operation__descriptor =
3236 {
3237   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3238   "MumbleProto.ContextActionModify.Operation",
3239   "Operation",
3240   "MumbleProto__ContextActionModify__Operation",
3241   "MumbleProto",
3242   2,
3243   mumble_proto__context_action_modify__operation__enum_values_by_number,
3244   2,
3245   mumble_proto__context_action_modify__operation__enum_values_by_name,
3246   1,
3247   mumble_proto__context_action_modify__operation__value_ranges,
3248   NULL,NULL,NULL,NULL   /* reserved[1234] */
3249 };
3250 static const ProtobufCFieldDescriptor mumble_proto__context_action_modify__field_descriptors[4] =
3251 {
3252   {
3253     "action",
3254     1,
3255     PROTOBUF_C_LABEL_REQUIRED,
3256     PROTOBUF_C_TYPE_STRING,
3257     0,   /* quantifier_offset */
3258     offsetof(MumbleProto__ContextActionModify, action),
3259     NULL,
3260     NULL,
3261     0,             /* flags */
3262     0,NULL,NULL    /* reserved1,reserved2, etc */
3263   },
3264   {
3265     "text",
3266     2,
3267     PROTOBUF_C_LABEL_OPTIONAL,
3268     PROTOBUF_C_TYPE_STRING,
3269     0,   /* quantifier_offset */
3270     offsetof(MumbleProto__ContextActionModify, text),
3271     NULL,
3272     NULL,
3273     0,             /* flags */
3274     0,NULL,NULL    /* reserved1,reserved2, etc */
3275   },
3276   {
3277     "context",
3278     3,
3279     PROTOBUF_C_LABEL_OPTIONAL,
3280     PROTOBUF_C_TYPE_UINT32,
3281     offsetof(MumbleProto__ContextActionModify, has_context),
3282     offsetof(MumbleProto__ContextActionModify, context),
3283     NULL,
3284     NULL,
3285     0,             /* flags */
3286     0,NULL,NULL    /* reserved1,reserved2, etc */
3287   },
3288   {
3289     "operation",
3290     4,
3291     PROTOBUF_C_LABEL_OPTIONAL,
3292     PROTOBUF_C_TYPE_ENUM,
3293     offsetof(MumbleProto__ContextActionModify, has_operation),
3294     offsetof(MumbleProto__ContextActionModify, operation),
3295     &mumble_proto__context_action_modify__operation__descriptor,
3296     NULL,
3297     0,             /* flags */
3298     0,NULL,NULL    /* reserved1,reserved2, etc */
3299   },
3300 };
3301 static const unsigned mumble_proto__context_action_modify__field_indices_by_name[] = {
3302   0,   /* field[0] = action */
3303   2,   /* field[2] = context */
3304   3,   /* field[3] = operation */
3305   1,   /* field[1] = text */
3306 };
3307 static const ProtobufCIntRange mumble_proto__context_action_modify__number_ranges[1 + 1] =
3308 {
3309   { 1, 0 },
3310   { 0, 4 }
3311 };
3312 const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor =
3313 {
3314   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3315   "MumbleProto.ContextActionModify",
3316   "ContextActionModify",
3317   "MumbleProto__ContextActionModify",
3318   "MumbleProto",
3319   sizeof(MumbleProto__ContextActionModify),
3320   4,
3321   mumble_proto__context_action_modify__field_descriptors,
3322   mumble_proto__context_action_modify__field_indices_by_name,
3323   1,  mumble_proto__context_action_modify__number_ranges,
3324   (ProtobufCMessageInit) mumble_proto__context_action_modify__init,
3325   NULL,NULL,NULL    /* reserved[123] */
3326 };
3327 static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
3328 {
3329   {
3330     "session",
3331     1,
3332     PROTOBUF_C_LABEL_OPTIONAL,
3333     PROTOBUF_C_TYPE_UINT32,
3334     offsetof(MumbleProto__ContextAction, has_session),
3335     offsetof(MumbleProto__ContextAction, session),
3336     NULL,
3337     NULL,
3338     0,             /* flags */
3339     0,NULL,NULL    /* reserved1,reserved2, etc */
3340   },
3341   {
3342     "channel_id",
3343     2,
3344     PROTOBUF_C_LABEL_OPTIONAL,
3345     PROTOBUF_C_TYPE_UINT32,
3346     offsetof(MumbleProto__ContextAction, has_channel_id),
3347     offsetof(MumbleProto__ContextAction, channel_id),
3348     NULL,
3349     NULL,
3350     0,             /* flags */
3351     0,NULL,NULL    /* reserved1,reserved2, etc */
3352   },
3353   {
3354     "action",
3355     3,
3356     PROTOBUF_C_LABEL_REQUIRED,
3357     PROTOBUF_C_TYPE_STRING,
3358     0,   /* quantifier_offset */
3359     offsetof(MumbleProto__ContextAction, action),
3360     NULL,
3361     NULL,
3362     0,             /* flags */
3363     0,NULL,NULL    /* reserved1,reserved2, etc */
3364   },
3365 };
3366 static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
3367   2,   /* field[2] = action */
3368   1,   /* field[1] = channel_id */
3369   0,   /* field[0] = session */
3370 };
3371 static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
3372 {
3373   { 1, 0 },
3374   { 0, 3 }
3375 };
3376 const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
3377 {
3378   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3379   "MumbleProto.ContextAction",
3380   "ContextAction",
3381   "MumbleProto__ContextAction",
3382   "MumbleProto",
3383   sizeof(MumbleProto__ContextAction),
3384   3,
3385   mumble_proto__context_action__field_descriptors,
3386   mumble_proto__context_action__field_indices_by_name,
3387   1,  mumble_proto__context_action__number_ranges,
3388   (ProtobufCMessageInit) mumble_proto__context_action__init,
3389   NULL,NULL,NULL    /* reserved[123] */
3390 };
3391 static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
3392 {
3393   {
3394     "user_id",
3395     1,
3396     PROTOBUF_C_LABEL_REQUIRED,
3397     PROTOBUF_C_TYPE_UINT32,
3398     0,   /* quantifier_offset */
3399     offsetof(MumbleProto__UserList__User, user_id),
3400     NULL,
3401     NULL,
3402     0,             /* flags */
3403     0,NULL,NULL    /* reserved1,reserved2, etc */
3404   },
3405   {
3406     "name",
3407     2,
3408     PROTOBUF_C_LABEL_OPTIONAL,
3409     PROTOBUF_C_TYPE_STRING,
3410     0,   /* quantifier_offset */
3411     offsetof(MumbleProto__UserList__User, name),
3412     NULL,
3413     NULL,
3414     0,             /* flags */
3415     0,NULL,NULL    /* reserved1,reserved2, etc */
3416   },
3417 };
3418 static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
3419   1,   /* field[1] = name */
3420   0,   /* field[0] = user_id */
3421 };
3422 static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
3423 {
3424   { 1, 0 },
3425   { 0, 2 }
3426 };
3427 const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
3428 {
3429   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3430   "MumbleProto.UserList.User",
3431   "User",
3432   "MumbleProto__UserList__User",
3433   "MumbleProto",
3434   sizeof(MumbleProto__UserList__User),
3435   2,
3436   mumble_proto__user_list__user__field_descriptors,
3437   mumble_proto__user_list__user__field_indices_by_name,
3438   1,  mumble_proto__user_list__user__number_ranges,
3439   (ProtobufCMessageInit) mumble_proto__user_list__user__init,
3440   NULL,NULL,NULL    /* reserved[123] */
3441 };
3442 static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
3443 {
3444   {
3445     "users",
3446     1,
3447     PROTOBUF_C_LABEL_REPEATED,
3448     PROTOBUF_C_TYPE_MESSAGE,
3449     offsetof(MumbleProto__UserList, n_users),
3450     offsetof(MumbleProto__UserList, users),
3451     &mumble_proto__user_list__user__descriptor,
3452     NULL,
3453     0,             /* flags */
3454     0,NULL,NULL    /* reserved1,reserved2, etc */
3455   },
3456 };
3457 static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
3458   0,   /* field[0] = users */
3459 };
3460 static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
3461 {
3462   { 1, 0 },
3463   { 0, 1 }
3464 };
3465 const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
3466 {
3467   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3468   "MumbleProto.UserList",
3469   "UserList",
3470   "MumbleProto__UserList",
3471   "MumbleProto",
3472   sizeof(MumbleProto__UserList),
3473   1,
3474   mumble_proto__user_list__field_descriptors,
3475   mumble_proto__user_list__field_indices_by_name,
3476   1,  mumble_proto__user_list__number_ranges,
3477   (ProtobufCMessageInit) mumble_proto__user_list__init,
3478   NULL,NULL,NULL    /* reserved[123] */
3479 };
3480 static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
3481 static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
3482 static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
3483 {
3484   {
3485     "session",
3486     1,
3487     PROTOBUF_C_LABEL_REPEATED,
3488     PROTOBUF_C_TYPE_UINT32,
3489     offsetof(MumbleProto__VoiceTarget__Target, n_session),
3490     offsetof(MumbleProto__VoiceTarget__Target, session),
3491     NULL,
3492     NULL,
3493     0,             /* flags */
3494     0,NULL,NULL    /* reserved1,reserved2, etc */
3495   },
3496   {
3497     "channel_id",
3498     2,
3499     PROTOBUF_C_LABEL_OPTIONAL,
3500     PROTOBUF_C_TYPE_UINT32,
3501     offsetof(MumbleProto__VoiceTarget__Target, has_channel_id),
3502     offsetof(MumbleProto__VoiceTarget__Target, channel_id),
3503     NULL,
3504     NULL,
3505     0,             /* flags */
3506     0,NULL,NULL    /* reserved1,reserved2, etc */
3507   },
3508   {
3509     "group",
3510     3,
3511     PROTOBUF_C_LABEL_OPTIONAL,
3512     PROTOBUF_C_TYPE_STRING,
3513     0,   /* quantifier_offset */
3514     offsetof(MumbleProto__VoiceTarget__Target, group),
3515     NULL,
3516     NULL,
3517     0,             /* flags */
3518     0,NULL,NULL    /* reserved1,reserved2, etc */
3519   },
3520   {
3521     "links",
3522     4,
3523     PROTOBUF_C_LABEL_OPTIONAL,
3524     PROTOBUF_C_TYPE_BOOL,
3525     offsetof(MumbleProto__VoiceTarget__Target, has_links),
3526     offsetof(MumbleProto__VoiceTarget__Target, links),
3527     NULL,
3528     &mumble_proto__voice_target__target__links__default_value,
3529     0,             /* flags */
3530     0,NULL,NULL    /* reserved1,reserved2, etc */
3531   },
3532   {
3533     "children",
3534     5,
3535     PROTOBUF_C_LABEL_OPTIONAL,
3536     PROTOBUF_C_TYPE_BOOL,
3537     offsetof(MumbleProto__VoiceTarget__Target, has_children),
3538     offsetof(MumbleProto__VoiceTarget__Target, children),
3539     NULL,
3540     &mumble_proto__voice_target__target__children__default_value,
3541     0,             /* flags */
3542     0,NULL,NULL    /* reserved1,reserved2, etc */
3543   },
3544 };
3545 static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
3546   1,   /* field[1] = channel_id */
3547   4,   /* field[4] = children */
3548   2,   /* field[2] = group */
3549   3,   /* field[3] = links */
3550   0,   /* field[0] = session */
3551 };
3552 static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
3553 {
3554   { 1, 0 },
3555   { 0, 5 }
3556 };
3557 const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
3558 {
3559   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3560   "MumbleProto.VoiceTarget.Target",
3561   "Target",
3562   "MumbleProto__VoiceTarget__Target",
3563   "MumbleProto",
3564   sizeof(MumbleProto__VoiceTarget__Target),
3565   5,
3566   mumble_proto__voice_target__target__field_descriptors,
3567   mumble_proto__voice_target__target__field_indices_by_name,
3568   1,  mumble_proto__voice_target__target__number_ranges,
3569   (ProtobufCMessageInit) mumble_proto__voice_target__target__init,
3570   NULL,NULL,NULL    /* reserved[123] */
3571 };
3572 static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
3573 {
3574   {
3575     "id",
3576     1,
3577     PROTOBUF_C_LABEL_OPTIONAL,
3578     PROTOBUF_C_TYPE_UINT32,
3579     offsetof(MumbleProto__VoiceTarget, has_id),
3580     offsetof(MumbleProto__VoiceTarget, id),
3581     NULL,
3582     NULL,
3583     0,             /* flags */
3584     0,NULL,NULL    /* reserved1,reserved2, etc */
3585   },
3586   {
3587     "targets",
3588     2,
3589     PROTOBUF_C_LABEL_REPEATED,
3590     PROTOBUF_C_TYPE_MESSAGE,
3591     offsetof(MumbleProto__VoiceTarget, n_targets),
3592     offsetof(MumbleProto__VoiceTarget, targets),
3593     &mumble_proto__voice_target__target__descriptor,
3594     NULL,
3595     0,             /* flags */
3596     0,NULL,NULL    /* reserved1,reserved2, etc */
3597   },
3598 };
3599 static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
3600   0,   /* field[0] = id */
3601   1,   /* field[1] = targets */
3602 };
3603 static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
3604 {
3605   { 1, 0 },
3606   { 0, 2 }
3607 };
3608 const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
3609 {
3610   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3611   "MumbleProto.VoiceTarget",
3612   "VoiceTarget",
3613   "MumbleProto__VoiceTarget",
3614   "MumbleProto",
3615   sizeof(MumbleProto__VoiceTarget),
3616   2,
3617   mumble_proto__voice_target__field_descriptors,
3618   mumble_proto__voice_target__field_indices_by_name,
3619   1,  mumble_proto__voice_target__number_ranges,
3620   (ProtobufCMessageInit) mumble_proto__voice_target__init,
3621   NULL,NULL,NULL    /* reserved[123] */
3622 };
3623 static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
3624 static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
3625 {
3626   {
3627     "channel_id",
3628     1,
3629     PROTOBUF_C_LABEL_OPTIONAL,
3630     PROTOBUF_C_TYPE_UINT32,
3631     offsetof(MumbleProto__PermissionQuery, has_channel_id),
3632     offsetof(MumbleProto__PermissionQuery, channel_id),
3633     NULL,
3634     NULL,
3635     0,             /* flags */
3636     0,NULL,NULL    /* reserved1,reserved2, etc */
3637   },
3638   {
3639     "permissions",
3640     2,
3641     PROTOBUF_C_LABEL_OPTIONAL,
3642     PROTOBUF_C_TYPE_UINT32,
3643     offsetof(MumbleProto__PermissionQuery, has_permissions),
3644     offsetof(MumbleProto__PermissionQuery, permissions),
3645     NULL,
3646     NULL,
3647     0,             /* flags */
3648     0,NULL,NULL    /* reserved1,reserved2, etc */
3649   },
3650   {
3651     "flush",
3652     3,
3653     PROTOBUF_C_LABEL_OPTIONAL,
3654     PROTOBUF_C_TYPE_BOOL,
3655     offsetof(MumbleProto__PermissionQuery, has_flush),
3656     offsetof(MumbleProto__PermissionQuery, flush),
3657     NULL,
3658     &mumble_proto__permission_query__flush__default_value,
3659     0,             /* flags */
3660     0,NULL,NULL    /* reserved1,reserved2, etc */
3661   },
3662 };
3663 static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
3664   0,   /* field[0] = channel_id */
3665   2,   /* field[2] = flush */
3666   1,   /* field[1] = permissions */
3667 };
3668 static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
3669 {
3670   { 1, 0 },
3671   { 0, 3 }
3672 };
3673 const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
3674 {
3675   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3676   "MumbleProto.PermissionQuery",
3677   "PermissionQuery",
3678   "MumbleProto__PermissionQuery",
3679   "MumbleProto",
3680   sizeof(MumbleProto__PermissionQuery),
3681   3,
3682   mumble_proto__permission_query__field_descriptors,
3683   mumble_proto__permission_query__field_indices_by_name,
3684   1,  mumble_proto__permission_query__number_ranges,
3685   (ProtobufCMessageInit) mumble_proto__permission_query__init,
3686   NULL,NULL,NULL    /* reserved[123] */
3687 };
3688 static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
3689 static const protobuf_c_boolean mumble_proto__codec_version__opus__default_value = 0;
3690 static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[4] =
3691 {
3692   {
3693     "alpha",
3694     1,
3695     PROTOBUF_C_LABEL_REQUIRED,
3696     PROTOBUF_C_TYPE_INT32,
3697     0,   /* quantifier_offset */
3698     offsetof(MumbleProto__CodecVersion, alpha),
3699     NULL,
3700     NULL,
3701     0,             /* flags */
3702     0,NULL,NULL    /* reserved1,reserved2, etc */
3703   },
3704   {
3705     "beta",
3706     2,
3707     PROTOBUF_C_LABEL_REQUIRED,
3708     PROTOBUF_C_TYPE_INT32,
3709     0,   /* quantifier_offset */
3710     offsetof(MumbleProto__CodecVersion, beta),
3711     NULL,
3712     NULL,
3713     0,             /* flags */
3714     0,NULL,NULL    /* reserved1,reserved2, etc */
3715   },
3716   {
3717     "prefer_alpha",
3718     3,
3719     PROTOBUF_C_LABEL_REQUIRED,
3720     PROTOBUF_C_TYPE_BOOL,
3721     0,   /* quantifier_offset */
3722     offsetof(MumbleProto__CodecVersion, prefer_alpha),
3723     NULL,
3724     &mumble_proto__codec_version__prefer_alpha__default_value,
3725     0,             /* flags */
3726     0,NULL,NULL    /* reserved1,reserved2, etc */
3727   },
3728   {
3729     "opus",
3730     4,
3731     PROTOBUF_C_LABEL_OPTIONAL,
3732     PROTOBUF_C_TYPE_BOOL,
3733     offsetof(MumbleProto__CodecVersion, has_opus),
3734     offsetof(MumbleProto__CodecVersion, opus),
3735     NULL,
3736     &mumble_proto__codec_version__opus__default_value,
3737     0,             /* flags */
3738     0,NULL,NULL    /* reserved1,reserved2, etc */
3739   },
3740 };
3741 static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
3742   0,   /* field[0] = alpha */
3743   1,   /* field[1] = beta */
3744   3,   /* field[3] = opus */
3745   2,   /* field[2] = prefer_alpha */
3746 };
3747 static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
3748 {
3749   { 1, 0 },
3750   { 0, 4 }
3751 };
3752 const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
3753 {
3754   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3755   "MumbleProto.CodecVersion",
3756   "CodecVersion",
3757   "MumbleProto__CodecVersion",
3758   "MumbleProto",
3759   sizeof(MumbleProto__CodecVersion),
3760   4,
3761   mumble_proto__codec_version__field_descriptors,
3762   mumble_proto__codec_version__field_indices_by_name,
3763   1,  mumble_proto__codec_version__number_ranges,
3764   (ProtobufCMessageInit) mumble_proto__codec_version__init,
3765   NULL,NULL,NULL    /* reserved[123] */
3766 };
3767 static const ProtobufCFieldDescriptor mumble_proto__user_stats__stats__field_descriptors[4] =
3768 {
3769   {
3770     "good",
3771     1,
3772     PROTOBUF_C_LABEL_OPTIONAL,
3773     PROTOBUF_C_TYPE_UINT32,
3774     offsetof(MumbleProto__UserStats__Stats, has_good),
3775     offsetof(MumbleProto__UserStats__Stats, good),
3776     NULL,
3777     NULL,
3778     0,             /* flags */
3779     0,NULL,NULL    /* reserved1,reserved2, etc */
3780   },
3781   {
3782     "late",
3783     2,
3784     PROTOBUF_C_LABEL_OPTIONAL,
3785     PROTOBUF_C_TYPE_UINT32,
3786     offsetof(MumbleProto__UserStats__Stats, has_late),
3787     offsetof(MumbleProto__UserStats__Stats, late),
3788     NULL,
3789     NULL,
3790     0,             /* flags */
3791     0,NULL,NULL    /* reserved1,reserved2, etc */
3792   },
3793   {
3794     "lost",
3795     3,
3796     PROTOBUF_C_LABEL_OPTIONAL,
3797     PROTOBUF_C_TYPE_UINT32,
3798     offsetof(MumbleProto__UserStats__Stats, has_lost),
3799     offsetof(MumbleProto__UserStats__Stats, lost),
3800     NULL,
3801     NULL,
3802     0,             /* flags */
3803     0,NULL,NULL    /* reserved1,reserved2, etc */
3804   },
3805   {
3806     "resync",
3807     4,
3808     PROTOBUF_C_LABEL_OPTIONAL,
3809     PROTOBUF_C_TYPE_UINT32,
3810     offsetof(MumbleProto__UserStats__Stats, has_resync),
3811     offsetof(MumbleProto__UserStats__Stats, resync),
3812     NULL,
3813     NULL,
3814     0,             /* flags */
3815     0,NULL,NULL    /* reserved1,reserved2, etc */
3816   },
3817 };
3818 static const unsigned mumble_proto__user_stats__stats__field_indices_by_name[] = {
3819   0,   /* field[0] = good */
3820   1,   /* field[1] = late */
3821   2,   /* field[2] = lost */
3822   3,   /* field[3] = resync */
3823 };
3824 static const ProtobufCIntRange mumble_proto__user_stats__stats__number_ranges[1 + 1] =
3825 {
3826   { 1, 0 },
3827   { 0, 4 }
3828 };
3829 const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor =
3830 {
3831   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3832   "MumbleProto.UserStats.Stats",
3833   "Stats",
3834   "MumbleProto__UserStats__Stats",
3835   "MumbleProto",
3836   sizeof(MumbleProto__UserStats__Stats),
3837   4,
3838   mumble_proto__user_stats__stats__field_descriptors,
3839   mumble_proto__user_stats__stats__field_indices_by_name,
3840   1,  mumble_proto__user_stats__stats__number_ranges,
3841   (ProtobufCMessageInit) mumble_proto__user_stats__stats__init,
3842   NULL,NULL,NULL    /* reserved[123] */
3843 };
3844 static const protobuf_c_boolean mumble_proto__user_stats__stats_only__default_value = 0;
3845 static const protobuf_c_boolean mumble_proto__user_stats__strong_certificate__default_value = 0;
3846 static const protobuf_c_boolean mumble_proto__user_stats__opus__default_value = 0;
3847 static const ProtobufCFieldDescriptor mumble_proto__user_stats__field_descriptors[19] =
3848 {
3849   {
3850     "session",
3851     1,
3852     PROTOBUF_C_LABEL_OPTIONAL,
3853     PROTOBUF_C_TYPE_UINT32,
3854     offsetof(MumbleProto__UserStats, has_session),
3855     offsetof(MumbleProto__UserStats, session),
3856     NULL,
3857     NULL,
3858     0,             /* flags */
3859     0,NULL,NULL    /* reserved1,reserved2, etc */
3860   },
3861   {
3862     "stats_only",
3863     2,
3864     PROTOBUF_C_LABEL_OPTIONAL,
3865     PROTOBUF_C_TYPE_BOOL,
3866     offsetof(MumbleProto__UserStats, has_stats_only),
3867     offsetof(MumbleProto__UserStats, stats_only),
3868     NULL,
3869     &mumble_proto__user_stats__stats_only__default_value,
3870     0,             /* flags */
3871     0,NULL,NULL    /* reserved1,reserved2, etc */
3872   },
3873   {
3874     "certificates",
3875     3,
3876     PROTOBUF_C_LABEL_REPEATED,
3877     PROTOBUF_C_TYPE_BYTES,
3878     offsetof(MumbleProto__UserStats, n_certificates),
3879     offsetof(MumbleProto__UserStats, certificates),
3880     NULL,
3881     NULL,
3882     0,             /* flags */
3883     0,NULL,NULL    /* reserved1,reserved2, etc */
3884   },
3885   {
3886     "from_client",
3887     4,
3888     PROTOBUF_C_LABEL_OPTIONAL,
3889     PROTOBUF_C_TYPE_MESSAGE,
3890     0,   /* quantifier_offset */
3891     offsetof(MumbleProto__UserStats, from_client),
3892     &mumble_proto__user_stats__stats__descriptor,
3893     NULL,
3894     0,             /* flags */
3895     0,NULL,NULL    /* reserved1,reserved2, etc */
3896   },
3897   {
3898     "from_server",
3899     5,
3900     PROTOBUF_C_LABEL_OPTIONAL,
3901     PROTOBUF_C_TYPE_MESSAGE,
3902     0,   /* quantifier_offset */
3903     offsetof(MumbleProto__UserStats, from_server),
3904     &mumble_proto__user_stats__stats__descriptor,
3905     NULL,
3906     0,             /* flags */
3907     0,NULL,NULL    /* reserved1,reserved2, etc */
3908   },
3909   {
3910     "udp_packets",
3911     6,
3912     PROTOBUF_C_LABEL_OPTIONAL,
3913     PROTOBUF_C_TYPE_UINT32,
3914     offsetof(MumbleProto__UserStats, has_udp_packets),
3915     offsetof(MumbleProto__UserStats, udp_packets),
3916     NULL,
3917     NULL,
3918     0,             /* flags */
3919     0,NULL,NULL    /* reserved1,reserved2, etc */
3920   },
3921   {
3922     "tcp_packets",
3923     7,
3924     PROTOBUF_C_LABEL_OPTIONAL,
3925     PROTOBUF_C_TYPE_UINT32,
3926     offsetof(MumbleProto__UserStats, has_tcp_packets),
3927     offsetof(MumbleProto__UserStats, tcp_packets),
3928     NULL,
3929     NULL,
3930     0,             /* flags */
3931     0,NULL,NULL    /* reserved1,reserved2, etc */
3932   },
3933   {
3934     "udp_ping_avg",
3935     8,
3936     PROTOBUF_C_LABEL_OPTIONAL,
3937     PROTOBUF_C_TYPE_FLOAT,
3938     offsetof(MumbleProto__UserStats, has_udp_ping_avg),
3939     offsetof(MumbleProto__UserStats, udp_ping_avg),
3940     NULL,
3941     NULL,
3942     0,             /* flags */
3943     0,NULL,NULL    /* reserved1,reserved2, etc */
3944   },
3945   {
3946     "udp_ping_var",
3947     9,
3948     PROTOBUF_C_LABEL_OPTIONAL,
3949     PROTOBUF_C_TYPE_FLOAT,
3950     offsetof(MumbleProto__UserStats, has_udp_ping_var),
3951     offsetof(MumbleProto__UserStats, udp_ping_var),
3952     NULL,
3953     NULL,
3954     0,             /* flags */
3955     0,NULL,NULL    /* reserved1,reserved2, etc */
3956   },
3957   {
3958     "tcp_ping_avg",
3959     10,
3960     PROTOBUF_C_LABEL_OPTIONAL,
3961     PROTOBUF_C_TYPE_FLOAT,
3962     offsetof(MumbleProto__UserStats, has_tcp_ping_avg),
3963     offsetof(MumbleProto__UserStats, tcp_ping_avg),
3964     NULL,
3965     NULL,
3966     0,             /* flags */
3967     0,NULL,NULL    /* reserved1,reserved2, etc */
3968   },
3969   {
3970     "tcp_ping_var",
3971     11,
3972     PROTOBUF_C_LABEL_OPTIONAL,
3973     PROTOBUF_C_TYPE_FLOAT,
3974     offsetof(MumbleProto__UserStats, has_tcp_ping_var),
3975     offsetof(MumbleProto__UserStats, tcp_ping_var),
3976     NULL,
3977     NULL,
3978     0,             /* flags */
3979     0,NULL,NULL    /* reserved1,reserved2, etc */
3980   },
3981   {
3982     "version",
3983     12,
3984     PROTOBUF_C_LABEL_OPTIONAL,
3985     PROTOBUF_C_TYPE_MESSAGE,
3986     0,   /* quantifier_offset */
3987     offsetof(MumbleProto__UserStats, version),
3988     &mumble_proto__version__descriptor,
3989     NULL,
3990     0,             /* flags */
3991     0,NULL,NULL    /* reserved1,reserved2, etc */
3992   },
3993   {
3994     "celt_versions",
3995     13,
3996     PROTOBUF_C_LABEL_REPEATED,
3997     PROTOBUF_C_TYPE_INT32,
3998     offsetof(MumbleProto__UserStats, n_celt_versions),
3999     offsetof(MumbleProto__UserStats, celt_versions),
4000     NULL,
4001     NULL,
4002     0,             /* flags */
4003     0,NULL,NULL    /* reserved1,reserved2, etc */
4004   },
4005   {
4006     "address",
4007     14,
4008     PROTOBUF_C_LABEL_OPTIONAL,
4009     PROTOBUF_C_TYPE_BYTES,
4010     offsetof(MumbleProto__UserStats, has_address),
4011     offsetof(MumbleProto__UserStats, address),
4012     NULL,
4013     NULL,
4014     0,             /* flags */
4015     0,NULL,NULL    /* reserved1,reserved2, etc */
4016   },
4017   {
4018     "bandwidth",
4019     15,
4020     PROTOBUF_C_LABEL_OPTIONAL,
4021     PROTOBUF_C_TYPE_UINT32,
4022     offsetof(MumbleProto__UserStats, has_bandwidth),
4023     offsetof(MumbleProto__UserStats, bandwidth),
4024     NULL,
4025     NULL,
4026     0,             /* flags */
4027     0,NULL,NULL    /* reserved1,reserved2, etc */
4028   },
4029   {
4030     "onlinesecs",
4031     16,
4032     PROTOBUF_C_LABEL_OPTIONAL,
4033     PROTOBUF_C_TYPE_UINT32,
4034     offsetof(MumbleProto__UserStats, has_onlinesecs),
4035     offsetof(MumbleProto__UserStats, onlinesecs),
4036     NULL,
4037     NULL,
4038     0,             /* flags */
4039     0,NULL,NULL    /* reserved1,reserved2, etc */
4040   },
4041   {
4042     "idlesecs",
4043     17,
4044     PROTOBUF_C_LABEL_OPTIONAL,
4045     PROTOBUF_C_TYPE_UINT32,
4046     offsetof(MumbleProto__UserStats, has_idlesecs),
4047     offsetof(MumbleProto__UserStats, idlesecs),
4048     NULL,
4049     NULL,
4050     0,             /* flags */
4051     0,NULL,NULL    /* reserved1,reserved2, etc */
4052   },
4053   {
4054     "strong_certificate",
4055     18,
4056     PROTOBUF_C_LABEL_OPTIONAL,
4057     PROTOBUF_C_TYPE_BOOL,
4058     offsetof(MumbleProto__UserStats, has_strong_certificate),
4059     offsetof(MumbleProto__UserStats, strong_certificate),
4060     NULL,
4061     &mumble_proto__user_stats__strong_certificate__default_value,
4062     0,             /* flags */
4063     0,NULL,NULL    /* reserved1,reserved2, etc */
4064   },
4065   {
4066     "opus",
4067     19,
4068     PROTOBUF_C_LABEL_OPTIONAL,
4069     PROTOBUF_C_TYPE_BOOL,
4070     offsetof(MumbleProto__UserStats, has_opus),
4071     offsetof(MumbleProto__UserStats, opus),
4072     NULL,
4073     &mumble_proto__user_stats__opus__default_value,
4074     0,             /* flags */
4075     0,NULL,NULL    /* reserved1,reserved2, etc */
4076   },
4077 };
4078 static const unsigned mumble_proto__user_stats__field_indices_by_name[] = {
4079   13,   /* field[13] = address */
4080   14,   /* field[14] = bandwidth */
4081   12,   /* field[12] = celt_versions */
4082   2,   /* field[2] = certificates */
4083   3,   /* field[3] = from_client */
4084   4,   /* field[4] = from_server */
4085   16,   /* field[16] = idlesecs */
4086   15,   /* field[15] = onlinesecs */
4087   18,   /* field[18] = opus */
4088   0,   /* field[0] = session */
4089   1,   /* field[1] = stats_only */
4090   17,   /* field[17] = strong_certificate */
4091   6,   /* field[6] = tcp_packets */
4092   9,   /* field[9] = tcp_ping_avg */
4093   10,   /* field[10] = tcp_ping_var */
4094   5,   /* field[5] = udp_packets */
4095   7,   /* field[7] = udp_ping_avg */
4096   8,   /* field[8] = udp_ping_var */
4097   11,   /* field[11] = version */
4098 };
4099 static const ProtobufCIntRange mumble_proto__user_stats__number_ranges[1 + 1] =
4100 {
4101   { 1, 0 },
4102   { 0, 19 }
4103 };
4104 const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor =
4105 {
4106   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4107   "MumbleProto.UserStats",
4108   "UserStats",
4109   "MumbleProto__UserStats",
4110   "MumbleProto",
4111   sizeof(MumbleProto__UserStats),
4112   19,
4113   mumble_proto__user_stats__field_descriptors,
4114   mumble_proto__user_stats__field_indices_by_name,
4115   1,  mumble_proto__user_stats__number_ranges,
4116   (ProtobufCMessageInit) mumble_proto__user_stats__init,
4117   NULL,NULL,NULL    /* reserved[123] */
4118 };
4119 static const ProtobufCFieldDescriptor mumble_proto__suggest_config__field_descriptors[3] =
4120 {
4121   {
4122     "version",
4123     1,
4124     PROTOBUF_C_LABEL_OPTIONAL,
4125     PROTOBUF_C_TYPE_UINT32,
4126     offsetof(MumbleProto__SuggestConfig, has_version),
4127     offsetof(MumbleProto__SuggestConfig, version),
4128     NULL,
4129     NULL,
4130     0,             /* flags */
4131     0,NULL,NULL    /* reserved1,reserved2, etc */
4132   },
4133   {
4134     "positional",
4135     2,
4136     PROTOBUF_C_LABEL_OPTIONAL,
4137     PROTOBUF_C_TYPE_BOOL,
4138     offsetof(MumbleProto__SuggestConfig, has_positional),
4139     offsetof(MumbleProto__SuggestConfig, positional),
4140     NULL,
4141     NULL,
4142     0,             /* flags */
4143     0,NULL,NULL    /* reserved1,reserved2, etc */
4144   },
4145   {
4146     "push_to_talk",
4147     3,
4148     PROTOBUF_C_LABEL_OPTIONAL,
4149     PROTOBUF_C_TYPE_BOOL,
4150     offsetof(MumbleProto__SuggestConfig, has_push_to_talk),
4151     offsetof(MumbleProto__SuggestConfig, push_to_talk),
4152     NULL,
4153     NULL,
4154     0,             /* flags */
4155     0,NULL,NULL    /* reserved1,reserved2, etc */
4156   },
4157 };
4158 static const unsigned mumble_proto__suggest_config__field_indices_by_name[] = {
4159   1,   /* field[1] = positional */
4160   2,   /* field[2] = push_to_talk */
4161   0,   /* field[0] = version */
4162 };
4163 static const ProtobufCIntRange mumble_proto__suggest_config__number_ranges[1 + 1] =
4164 {
4165   { 1, 0 },
4166   { 0, 3 }
4167 };
4168 const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor =
4169 {
4170   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4171   "MumbleProto.SuggestConfig",
4172   "SuggestConfig",
4173   "MumbleProto__SuggestConfig",
4174   "MumbleProto",
4175   sizeof(MumbleProto__SuggestConfig),
4176   3,
4177   mumble_proto__suggest_config__field_descriptors,
4178   mumble_proto__suggest_config__field_indices_by_name,
4179   1,  mumble_proto__suggest_config__number_ranges,
4180   (ProtobufCMessageInit) mumble_proto__suggest_config__init,
4181   NULL,NULL,NULL    /* reserved[123] */
4182 };
4183 static const ProtobufCFieldDescriptor mumble_proto__request_blob__field_descriptors[3] =
4184 {
4185   {
4186     "session_texture",
4187     1,
4188     PROTOBUF_C_LABEL_REPEATED,
4189     PROTOBUF_C_TYPE_UINT32,
4190     offsetof(MumbleProto__RequestBlob, n_session_texture),
4191     offsetof(MumbleProto__RequestBlob, session_texture),
4192     NULL,
4193     NULL,
4194     0,             /* flags */
4195     0,NULL,NULL    /* reserved1,reserved2, etc */
4196   },
4197   {
4198     "session_comment",
4199     2,
4200     PROTOBUF_C_LABEL_REPEATED,
4201     PROTOBUF_C_TYPE_UINT32,
4202     offsetof(MumbleProto__RequestBlob, n_session_comment),
4203     offsetof(MumbleProto__RequestBlob, session_comment),
4204     NULL,
4205     NULL,
4206     0,             /* flags */
4207     0,NULL,NULL    /* reserved1,reserved2, etc */
4208   },
4209   {
4210     "channel_description",
4211     3,
4212     PROTOBUF_C_LABEL_REPEATED,
4213     PROTOBUF_C_TYPE_UINT32,
4214     offsetof(MumbleProto__RequestBlob, n_channel_description),
4215     offsetof(MumbleProto__RequestBlob, channel_description),
4216     NULL,
4217     NULL,
4218     0,             /* flags */
4219     0,NULL,NULL    /* reserved1,reserved2, etc */
4220   },
4221 };
4222 static const unsigned mumble_proto__request_blob__field_indices_by_name[] = {
4223   2,   /* field[2] = channel_description */
4224   1,   /* field[1] = session_comment */
4225   0,   /* field[0] = session_texture */
4226 };
4227 static const ProtobufCIntRange mumble_proto__request_blob__number_ranges[1 + 1] =
4228 {
4229   { 1, 0 },
4230   { 0, 3 }
4231 };
4232 const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor =
4233 {
4234   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4235   "MumbleProto.RequestBlob",
4236   "RequestBlob",
4237   "MumbleProto__RequestBlob",
4238   "MumbleProto",
4239   sizeof(MumbleProto__RequestBlob),
4240   3,
4241   mumble_proto__request_blob__field_descriptors,
4242   mumble_proto__request_blob__field_indices_by_name,
4243   1,  mumble_proto__request_blob__number_ranges,
4244   (ProtobufCMessageInit) mumble_proto__request_blob__init,
4245   NULL,NULL,NULL    /* reserved[123] */
4246 };