src/Mumble.pb-c.c

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