// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mumble.proto

#include "StdInc.h"

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "mumble.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace MumbleProto {

void protobuf_ShutdownFile_mumble_2eproto() {
  delete Version::default_instance_;
  delete UDPTunnel::default_instance_;
  delete Authenticate::default_instance_;
  delete Ping::default_instance_;
  delete Reject::default_instance_;
  delete ServerSync::default_instance_;
  delete ChannelRemove::default_instance_;
  delete ChannelState::default_instance_;
  delete UserRemove::default_instance_;
  delete UserState::default_instance_;
  delete BanList::default_instance_;
  delete BanList_BanEntry::default_instance_;
  delete TextMessage::default_instance_;
  delete PermissionDenied::default_instance_;
  delete ACL::default_instance_;
  delete ACL_ChanGroup::default_instance_;
  delete ACL_ChanACL::default_instance_;
  delete QueryUsers::default_instance_;
  delete CryptSetup::default_instance_;
  delete ContextActionModify::default_instance_;
  delete ContextAction::default_instance_;
  delete UserList::default_instance_;
  delete UserList_User::default_instance_;
  delete VoiceTarget::default_instance_;
  delete VoiceTarget_Target::default_instance_;
  delete PermissionQuery::default_instance_;
  delete CodecVersion::default_instance_;
  delete UserStats::default_instance_;
  delete UserStats_Stats::default_instance_;
  delete RequestBlob::default_instance_;
  delete ServerConfig::default_instance_;
  delete SuggestConfig::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_mumble_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_mumble_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#endif
  Version::default_instance_ = new Version();
  UDPTunnel::default_instance_ = new UDPTunnel();
  Authenticate::default_instance_ = new Authenticate();
  Ping::default_instance_ = new Ping();
  Reject::default_instance_ = new Reject();
  ServerSync::default_instance_ = new ServerSync();
  ChannelRemove::default_instance_ = new ChannelRemove();
  ChannelState::default_instance_ = new ChannelState();
  UserRemove::default_instance_ = new UserRemove();
  UserState::default_instance_ = new UserState();
  BanList::default_instance_ = new BanList();
  BanList_BanEntry::default_instance_ = new BanList_BanEntry();
  TextMessage::default_instance_ = new TextMessage();
  PermissionDenied::default_instance_ = new PermissionDenied();
  ACL::default_instance_ = new ACL();
  ACL_ChanGroup::default_instance_ = new ACL_ChanGroup();
  ACL_ChanACL::default_instance_ = new ACL_ChanACL();
  QueryUsers::default_instance_ = new QueryUsers();
  CryptSetup::default_instance_ = new CryptSetup();
  ContextActionModify::default_instance_ = new ContextActionModify();
  ContextAction::default_instance_ = new ContextAction();
  UserList::default_instance_ = new UserList();
  UserList_User::default_instance_ = new UserList_User();
  VoiceTarget::default_instance_ = new VoiceTarget();
  VoiceTarget_Target::default_instance_ = new VoiceTarget_Target();
  PermissionQuery::default_instance_ = new PermissionQuery();
  CodecVersion::default_instance_ = new CodecVersion();
  UserStats::default_instance_ = new UserStats();
  UserStats_Stats::default_instance_ = new UserStats_Stats();
  RequestBlob::default_instance_ = new RequestBlob();
  ServerConfig::default_instance_ = new ServerConfig();
  SuggestConfig::default_instance_ = new SuggestConfig();
  Version::default_instance_->InitAsDefaultInstance();
  UDPTunnel::default_instance_->InitAsDefaultInstance();
  Authenticate::default_instance_->InitAsDefaultInstance();
  Ping::default_instance_->InitAsDefaultInstance();
  Reject::default_instance_->InitAsDefaultInstance();
  ServerSync::default_instance_->InitAsDefaultInstance();
  ChannelRemove::default_instance_->InitAsDefaultInstance();
  ChannelState::default_instance_->InitAsDefaultInstance();
  UserRemove::default_instance_->InitAsDefaultInstance();
  UserState::default_instance_->InitAsDefaultInstance();
  BanList::default_instance_->InitAsDefaultInstance();
  BanList_BanEntry::default_instance_->InitAsDefaultInstance();
  TextMessage::default_instance_->InitAsDefaultInstance();
  PermissionDenied::default_instance_->InitAsDefaultInstance();
  ACL::default_instance_->InitAsDefaultInstance();
  ACL_ChanGroup::default_instance_->InitAsDefaultInstance();
  ACL_ChanACL::default_instance_->InitAsDefaultInstance();
  QueryUsers::default_instance_->InitAsDefaultInstance();
  CryptSetup::default_instance_->InitAsDefaultInstance();
  ContextActionModify::default_instance_->InitAsDefaultInstance();
  ContextAction::default_instance_->InitAsDefaultInstance();
  UserList::default_instance_->InitAsDefaultInstance();
  UserList_User::default_instance_->InitAsDefaultInstance();
  VoiceTarget::default_instance_->InitAsDefaultInstance();
  VoiceTarget_Target::default_instance_->InitAsDefaultInstance();
  PermissionQuery::default_instance_->InitAsDefaultInstance();
  CodecVersion::default_instance_->InitAsDefaultInstance();
  UserStats::default_instance_->InitAsDefaultInstance();
  UserStats_Stats::default_instance_->InitAsDefaultInstance();
  RequestBlob::default_instance_->InitAsDefaultInstance();
  ServerConfig::default_instance_->InitAsDefaultInstance();
  SuggestConfig::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_mumble_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_mumble_2eproto_once_);
void protobuf_AddDesc_mumble_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_mumble_2eproto_once_,
                 &protobuf_AddDesc_mumble_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_mumble_2eproto {
  StaticDescriptorInitializer_mumble_2eproto() {
    protobuf_AddDesc_mumble_2eproto();
  }
} static_descriptor_initializer_mumble_2eproto_;
#endif

namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;
static void MergeFromFail(int line) {
  GOOGLE_CHECK(false) << __FILE__ << ":" << line;
}

}  // namespace


// ===================================================================

#ifndef _MSC_VER
const int Version::kVersionFieldNumber;
const int Version::kReleaseFieldNumber;
const int Version::kOsFieldNumber;
const int Version::kOsVersionFieldNumber;
#endif  // !_MSC_VER

Version::Version()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.Version)
}

void Version::InitAsDefaultInstance() {
}

Version::Version(const Version& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.Version)
}

void Version::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  version_ = 0u;
  release_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  os_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  os_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Version::~Version() {
  // @@protoc_insertion_point(destructor:MumbleProto.Version)
  SharedDtor();
}

void Version::SharedDtor() {
  release_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  os_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  os_version_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void Version::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Version& Version::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

Version* Version::default_instance_ = NULL;

Version* Version::New(::google::protobuf::Arena* arena) const {
  Version* n = new Version;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Version::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    version_ = 0u;
    if (has_release()) {
      release_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_os()) {
      os_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_os_version()) {
      os_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool Version::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.Version)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 version = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &version_)));
          set_has_version();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_release;
        break;
      }

      // optional string release = 2;
      case 2: {
        if (tag == 18) {
         parse_release:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_release()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_os;
        break;
      }

      // optional string os = 3;
      case 3: {
        if (tag == 26) {
         parse_os:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_os()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_os_version;
        break;
      }

      // optional string os_version = 4;
      case 4: {
        if (tag == 34) {
         parse_os_version:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_os_version()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.Version)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.Version)
  return false;
#undef DO_
}

void Version::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.Version)
  // optional uint32 version = 1;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->version(), output);
  }

  // optional string release = 2;
  if (has_release()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->release(), output);
  }

  // optional string os = 3;
  if (has_os()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->os(), output);
  }

  // optional string os_version = 4;
  if (has_os_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->os_version(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.Version)
}

int Version::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 15) {
    // optional uint32 version = 1;
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->version());
    }

    // optional string release = 2;
    if (has_release()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->release());
    }

    // optional string os = 3;
    if (has_os()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->os());
    }

    // optional string os_version = 4;
    if (has_os_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->os_version());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Version::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Version*>(&from));
}

void Version::MergeFrom(const Version& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_release()) {
      set_has_release();
      release_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.release_);
    }
    if (from.has_os()) {
      set_has_os();
      os_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.os_);
    }
    if (from.has_os_version()) {
      set_has_os_version();
      os_version_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.os_version_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void Version::CopyFrom(const Version& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Version::IsInitialized() const {

  return true;
}

void Version::Swap(Version* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Version::InternalSwap(Version* other) {
  std::swap(version_, other->version_);
  release_.Swap(&other->release_);
  os_.Swap(&other->os_);
  os_version_.Swap(&other->os_version_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Version::GetTypeName() const {
  return "MumbleProto.Version";
}


// ===================================================================

#ifndef _MSC_VER
const int UDPTunnel::kPacketFieldNumber;
#endif  // !_MSC_VER

UDPTunnel::UDPTunnel()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UDPTunnel)
}

void UDPTunnel::InitAsDefaultInstance() {
}

UDPTunnel::UDPTunnel(const UDPTunnel& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UDPTunnel)
}

void UDPTunnel::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  packet_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UDPTunnel::~UDPTunnel() {
  // @@protoc_insertion_point(destructor:MumbleProto.UDPTunnel)
  SharedDtor();
}

void UDPTunnel::SharedDtor() {
  packet_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UDPTunnel::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UDPTunnel& UDPTunnel::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UDPTunnel* UDPTunnel::default_instance_ = NULL;

UDPTunnel* UDPTunnel::New(::google::protobuf::Arena* arena) const {
  UDPTunnel* n = new UDPTunnel;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UDPTunnel::Clear() {
  if (has_packet()) {
    packet_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UDPTunnel::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UDPTunnel)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes packet = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_packet()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UDPTunnel)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UDPTunnel)
  return false;
#undef DO_
}

void UDPTunnel::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UDPTunnel)
  // required bytes packet = 1;
  if (has_packet()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->packet(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UDPTunnel)
}

int UDPTunnel::ByteSize() const {
  int total_size = 0;

  // required bytes packet = 1;
  if (has_packet()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->packet());
  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UDPTunnel::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UDPTunnel*>(&from));
}

void UDPTunnel::MergeFrom(const UDPTunnel& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet()) {
      set_has_packet();
      packet_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.packet_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UDPTunnel::CopyFrom(const UDPTunnel& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UDPTunnel::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void UDPTunnel::Swap(UDPTunnel* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UDPTunnel::InternalSwap(UDPTunnel* other) {
  packet_.Swap(&other->packet_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UDPTunnel::GetTypeName() const {
  return "MumbleProto.UDPTunnel";
}


// ===================================================================

#ifndef _MSC_VER
const int Authenticate::kUsernameFieldNumber;
const int Authenticate::kPasswordFieldNumber;
const int Authenticate::kTokensFieldNumber;
const int Authenticate::kCeltVersionsFieldNumber;
const int Authenticate::kOpusFieldNumber;
#endif  // !_MSC_VER

Authenticate::Authenticate()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.Authenticate)
}

void Authenticate::InitAsDefaultInstance() {
}

Authenticate::Authenticate(const Authenticate& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.Authenticate)
}

void Authenticate::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  username_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  password_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  opus_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Authenticate::~Authenticate() {
  // @@protoc_insertion_point(destructor:MumbleProto.Authenticate)
  SharedDtor();
}

void Authenticate::SharedDtor() {
  username_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  password_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void Authenticate::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Authenticate& Authenticate::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

Authenticate* Authenticate::default_instance_ = NULL;

Authenticate* Authenticate::New(::google::protobuf::Arena* arena) const {
  Authenticate* n = new Authenticate;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Authenticate::Clear() {
  if (_has_bits_[0 / 32] & 19) {
    if (has_username()) {
      username_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_password()) {
      password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    opus_ = false;
  }
  tokens_.Clear();
  celt_versions_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool Authenticate::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.Authenticate)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string username = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_username()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_password;
        break;
      }

      // optional string password = 2;
      case 2: {
        if (tag == 18) {
         parse_password:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_password()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_tokens;
        break;
      }

      // repeated string tokens = 3;
      case 3: {
        if (tag == 26) {
         parse_tokens:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_tokens()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_tokens;
        if (input->ExpectTag(32)) goto parse_celt_versions;
        break;
      }

      // repeated int32 celt_versions = 4;
      case 4: {
        if (tag == 32) {
         parse_celt_versions:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 32, input, this->mutable_celt_versions())));
        } else if (tag == 34) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_celt_versions())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_celt_versions;
        if (input->ExpectTag(40)) goto parse_opus;
        break;
      }

      // optional bool opus = 5 [default = false];
      case 5: {
        if (tag == 40) {
         parse_opus:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &opus_)));
          set_has_opus();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.Authenticate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.Authenticate)
  return false;
#undef DO_
}

void Authenticate::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.Authenticate)
  // optional string username = 1;
  if (has_username()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->username(), output);
  }

  // optional string password = 2;
  if (has_password()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->password(), output);
  }

  // repeated string tokens = 3;
  for (int i = 0; i < this->tokens_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->tokens(i), output);
  }

  // repeated int32 celt_versions = 4;
  for (int i = 0; i < this->celt_versions_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      4, this->celt_versions(i), output);
  }

  // optional bool opus = 5 [default = false];
  if (has_opus()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->opus(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.Authenticate)
}

int Authenticate::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 19) {
    // optional string username = 1;
    if (has_username()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->username());
    }

    // optional string password = 2;
    if (has_password()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->password());
    }

    // optional bool opus = 5 [default = false];
    if (has_opus()) {
      total_size += 1 + 1;
    }

  }
  // repeated string tokens = 3;
  total_size += 1 * this->tokens_size();
  for (int i = 0; i < this->tokens_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->tokens(i));
  }

  // repeated int32 celt_versions = 4;
  {
    int data_size = 0;
    for (int i = 0; i < this->celt_versions_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->celt_versions(i));
    }
    total_size += 1 * this->celt_versions_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Authenticate::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Authenticate*>(&from));
}

void Authenticate::MergeFrom(const Authenticate& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  tokens_.MergeFrom(from.tokens_);
  celt_versions_.MergeFrom(from.celt_versions_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_username()) {
      set_has_username();
      username_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.username_);
    }
    if (from.has_password()) {
      set_has_password();
      password_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.password_);
    }
    if (from.has_opus()) {
      set_opus(from.opus());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void Authenticate::CopyFrom(const Authenticate& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Authenticate::IsInitialized() const {

  return true;
}

void Authenticate::Swap(Authenticate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Authenticate::InternalSwap(Authenticate* other) {
  username_.Swap(&other->username_);
  password_.Swap(&other->password_);
  tokens_.UnsafeArenaSwap(&other->tokens_);
  celt_versions_.UnsafeArenaSwap(&other->celt_versions_);
  std::swap(opus_, other->opus_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Authenticate::GetTypeName() const {
  return "MumbleProto.Authenticate";
}


// ===================================================================

#ifndef _MSC_VER
const int Ping::kTimestampFieldNumber;
const int Ping::kGoodFieldNumber;
const int Ping::kLateFieldNumber;
const int Ping::kLostFieldNumber;
const int Ping::kResyncFieldNumber;
const int Ping::kUdpPacketsFieldNumber;
const int Ping::kTcpPacketsFieldNumber;
const int Ping::kUdpPingAvgFieldNumber;
const int Ping::kUdpPingVarFieldNumber;
const int Ping::kTcpPingAvgFieldNumber;
const int Ping::kTcpPingVarFieldNumber;
#endif  // !_MSC_VER

Ping::Ping()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.Ping)
}

void Ping::InitAsDefaultInstance() {
}

Ping::Ping(const Ping& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.Ping)
}

void Ping::SharedCtor() {
  _cached_size_ = 0;
  timestamp_ = GOOGLE_ULONGLONG(0);
  good_ = 0u;
  late_ = 0u;
  lost_ = 0u;
  resync_ = 0u;
  udp_packets_ = 0u;
  tcp_packets_ = 0u;
  udp_ping_avg_ = 0;
  udp_ping_var_ = 0;
  tcp_ping_avg_ = 0;
  tcp_ping_var_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Ping::~Ping() {
  // @@protoc_insertion_point(destructor:MumbleProto.Ping)
  SharedDtor();
}

void Ping::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void Ping::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Ping& Ping::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

Ping* Ping::default_instance_ = NULL;

Ping* Ping::New(::google::protobuf::Arena* arena) const {
  Ping* n = new Ping;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Ping::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Ping*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(timestamp_, udp_ping_avg_);
  }
  ZR_(udp_ping_var_, tcp_ping_var_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool Ping::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.Ping)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 timestamp = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &timestamp_)));
          set_has_timestamp();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_good;
        break;
      }

      // optional uint32 good = 2;
      case 2: {
        if (tag == 16) {
         parse_good:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &good_)));
          set_has_good();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_late;
        break;
      }

      // optional uint32 late = 3;
      case 3: {
        if (tag == 24) {
         parse_late:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &late_)));
          set_has_late();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_lost;
        break;
      }

      // optional uint32 lost = 4;
      case 4: {
        if (tag == 32) {
         parse_lost:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &lost_)));
          set_has_lost();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_resync;
        break;
      }

      // optional uint32 resync = 5;
      case 5: {
        if (tag == 40) {
         parse_resync:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &resync_)));
          set_has_resync();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_udp_packets;
        break;
      }

      // optional uint32 udp_packets = 6;
      case 6: {
        if (tag == 48) {
         parse_udp_packets:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &udp_packets_)));
          set_has_udp_packets();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_tcp_packets;
        break;
      }

      // optional uint32 tcp_packets = 7;
      case 7: {
        if (tag == 56) {
         parse_tcp_packets:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &tcp_packets_)));
          set_has_tcp_packets();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_udp_ping_avg;
        break;
      }

      // optional float udp_ping_avg = 8;
      case 8: {
        if (tag == 69) {
         parse_udp_ping_avg:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &udp_ping_avg_)));
          set_has_udp_ping_avg();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(77)) goto parse_udp_ping_var;
        break;
      }

      // optional float udp_ping_var = 9;
      case 9: {
        if (tag == 77) {
         parse_udp_ping_var:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &udp_ping_var_)));
          set_has_udp_ping_var();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(85)) goto parse_tcp_ping_avg;
        break;
      }

      // optional float tcp_ping_avg = 10;
      case 10: {
        if (tag == 85) {
         parse_tcp_ping_avg:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tcp_ping_avg_)));
          set_has_tcp_ping_avg();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(93)) goto parse_tcp_ping_var;
        break;
      }

      // optional float tcp_ping_var = 11;
      case 11: {
        if (tag == 93) {
         parse_tcp_ping_var:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tcp_ping_var_)));
          set_has_tcp_ping_var();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.Ping)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.Ping)
  return false;
#undef DO_
}

void Ping::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.Ping)
  // optional uint64 timestamp = 1;
  if (has_timestamp()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->timestamp(), output);
  }

  // optional uint32 good = 2;
  if (has_good()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->good(), output);
  }

  // optional uint32 late = 3;
  if (has_late()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->late(), output);
  }

  // optional uint32 lost = 4;
  if (has_lost()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->lost(), output);
  }

  // optional uint32 resync = 5;
  if (has_resync()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->resync(), output);
  }

  // optional uint32 udp_packets = 6;
  if (has_udp_packets()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->udp_packets(), output);
  }

  // optional uint32 tcp_packets = 7;
  if (has_tcp_packets()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->tcp_packets(), output);
  }

  // optional float udp_ping_avg = 8;
  if (has_udp_ping_avg()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->udp_ping_avg(), output);
  }

  // optional float udp_ping_var = 9;
  if (has_udp_ping_var()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->udp_ping_var(), output);
  }

  // optional float tcp_ping_avg = 10;
  if (has_tcp_ping_avg()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->tcp_ping_avg(), output);
  }

  // optional float tcp_ping_var = 11;
  if (has_tcp_ping_var()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->tcp_ping_var(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.Ping)
}

int Ping::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 255) {
    // optional uint64 timestamp = 1;
    if (has_timestamp()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->timestamp());
    }

    // optional uint32 good = 2;
    if (has_good()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->good());
    }

    // optional uint32 late = 3;
    if (has_late()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->late());
    }

    // optional uint32 lost = 4;
    if (has_lost()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->lost());
    }

    // optional uint32 resync = 5;
    if (has_resync()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->resync());
    }

    // optional uint32 udp_packets = 6;
    if (has_udp_packets()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->udp_packets());
    }

    // optional uint32 tcp_packets = 7;
    if (has_tcp_packets()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->tcp_packets());
    }

    // optional float udp_ping_avg = 8;
    if (has_udp_ping_avg()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & 1792) {
    // optional float udp_ping_var = 9;
    if (has_udp_ping_var()) {
      total_size += 1 + 4;
    }

    // optional float tcp_ping_avg = 10;
    if (has_tcp_ping_avg()) {
      total_size += 1 + 4;
    }

    // optional float tcp_ping_var = 11;
    if (has_tcp_ping_var()) {
      total_size += 1 + 4;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Ping::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Ping*>(&from));
}

void Ping::MergeFrom(const Ping& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_timestamp()) {
      set_timestamp(from.timestamp());
    }
    if (from.has_good()) {
      set_good(from.good());
    }
    if (from.has_late()) {
      set_late(from.late());
    }
    if (from.has_lost()) {
      set_lost(from.lost());
    }
    if (from.has_resync()) {
      set_resync(from.resync());
    }
    if (from.has_udp_packets()) {
      set_udp_packets(from.udp_packets());
    }
    if (from.has_tcp_packets()) {
      set_tcp_packets(from.tcp_packets());
    }
    if (from.has_udp_ping_avg()) {
      set_udp_ping_avg(from.udp_ping_avg());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_udp_ping_var()) {
      set_udp_ping_var(from.udp_ping_var());
    }
    if (from.has_tcp_ping_avg()) {
      set_tcp_ping_avg(from.tcp_ping_avg());
    }
    if (from.has_tcp_ping_var()) {
      set_tcp_ping_var(from.tcp_ping_var());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void Ping::CopyFrom(const Ping& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ping::IsInitialized() const {

  return true;
}

void Ping::Swap(Ping* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Ping::InternalSwap(Ping* other) {
  std::swap(timestamp_, other->timestamp_);
  std::swap(good_, other->good_);
  std::swap(late_, other->late_);
  std::swap(lost_, other->lost_);
  std::swap(resync_, other->resync_);
  std::swap(udp_packets_, other->udp_packets_);
  std::swap(tcp_packets_, other->tcp_packets_);
  std::swap(udp_ping_avg_, other->udp_ping_avg_);
  std::swap(udp_ping_var_, other->udp_ping_var_);
  std::swap(tcp_ping_avg_, other->tcp_ping_avg_);
  std::swap(tcp_ping_var_, other->tcp_ping_var_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Ping::GetTypeName() const {
  return "MumbleProto.Ping";
}


// ===================================================================

bool Reject_RejectType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const Reject_RejectType Reject::None;
const Reject_RejectType Reject::WrongVersion;
const Reject_RejectType Reject::InvalidUsername;
const Reject_RejectType Reject::WrongUserPW;
const Reject_RejectType Reject::WrongServerPW;
const Reject_RejectType Reject::UsernameInUse;
const Reject_RejectType Reject::ServerFull;
const Reject_RejectType Reject::NoCertificate;
const Reject_RejectType Reject::AuthenticatorFail;
const Reject_RejectType Reject::RejectType_MIN;
const Reject_RejectType Reject::RejectType_MAX;
const int Reject::RejectType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int Reject::kTypeFieldNumber;
const int Reject::kReasonFieldNumber;
#endif  // !_MSC_VER

Reject::Reject()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.Reject)
}

void Reject::InitAsDefaultInstance() {
}

Reject::Reject(const Reject& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.Reject)
}

void Reject::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  type_ = 0;
  reason_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Reject::~Reject() {
  // @@protoc_insertion_point(destructor:MumbleProto.Reject)
  SharedDtor();
}

void Reject::SharedDtor() {
  reason_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void Reject::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Reject& Reject::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

Reject* Reject::default_instance_ = NULL;

Reject* Reject::New(::google::protobuf::Arena* arena) const {
  Reject* n = new Reject;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Reject::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    type_ = 0;
    if (has_reason()) {
      reason_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool Reject::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.Reject)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .MumbleProto.Reject.RejectType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::MumbleProto::Reject_RejectType_IsValid(value)) {
            set_type(static_cast< ::MumbleProto::Reject_RejectType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_reason;
        break;
      }

      // optional string reason = 2;
      case 2: {
        if (tag == 18) {
         parse_reason:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_reason()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.Reject)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.Reject)
  return false;
#undef DO_
}

void Reject::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.Reject)
  // optional .MumbleProto.Reject.RejectType type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional string reason = 2;
  if (has_reason()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->reason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.Reject)
}

int Reject::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 3) {
    // optional .MumbleProto.Reject.RejectType type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional string reason = 2;
    if (has_reason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->reason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Reject::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Reject*>(&from));
}

void Reject::MergeFrom(const Reject& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_reason()) {
      set_has_reason();
      reason_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reason_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void Reject::CopyFrom(const Reject& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Reject::IsInitialized() const {

  return true;
}

void Reject::Swap(Reject* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Reject::InternalSwap(Reject* other) {
  std::swap(type_, other->type_);
  reason_.Swap(&other->reason_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Reject::GetTypeName() const {
  return "MumbleProto.Reject";
}


// ===================================================================

#ifndef _MSC_VER
const int ServerSync::kSessionFieldNumber;
const int ServerSync::kMaxBandwidthFieldNumber;
const int ServerSync::kWelcomeTextFieldNumber;
const int ServerSync::kPermissionsFieldNumber;
#endif  // !_MSC_VER

ServerSync::ServerSync()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ServerSync)
}

void ServerSync::InitAsDefaultInstance() {
}

ServerSync::ServerSync(const ServerSync& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ServerSync)
}

void ServerSync::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  session_ = 0u;
  max_bandwidth_ = 0u;
  welcome_text_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  permissions_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ServerSync::~ServerSync() {
  // @@protoc_insertion_point(destructor:MumbleProto.ServerSync)
  SharedDtor();
}

void ServerSync::SharedDtor() {
  welcome_text_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ServerSync::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ServerSync& ServerSync::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ServerSync* ServerSync::default_instance_ = NULL;

ServerSync* ServerSync::New(::google::protobuf::Arena* arena) const {
  ServerSync* n = new ServerSync;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ServerSync::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ServerSync*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(session_, max_bandwidth_);
    if (has_welcome_text()) {
      welcome_text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    permissions_ = GOOGLE_ULONGLONG(0);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ServerSync::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ServerSync)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 session = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_max_bandwidth;
        break;
      }

      // optional uint32 max_bandwidth = 2;
      case 2: {
        if (tag == 16) {
         parse_max_bandwidth:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_bandwidth_)));
          set_has_max_bandwidth();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_welcome_text;
        break;
      }

      // optional string welcome_text = 3;
      case 3: {
        if (tag == 26) {
         parse_welcome_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_welcome_text()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_permissions;
        break;
      }

      // optional uint64 permissions = 4;
      case 4: {
        if (tag == 32) {
         parse_permissions:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &permissions_)));
          set_has_permissions();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ServerSync)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ServerSync)
  return false;
#undef DO_
}

void ServerSync::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ServerSync)
  // optional uint32 session = 1;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->session(), output);
  }

  // optional uint32 max_bandwidth = 2;
  if (has_max_bandwidth()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->max_bandwidth(), output);
  }

  // optional string welcome_text = 3;
  if (has_welcome_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->welcome_text(), output);
  }

  // optional uint64 permissions = 4;
  if (has_permissions()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->permissions(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ServerSync)
}

int ServerSync::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 15) {
    // optional uint32 session = 1;
    if (has_session()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->session());
    }

    // optional uint32 max_bandwidth = 2;
    if (has_max_bandwidth()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_bandwidth());
    }

    // optional string welcome_text = 3;
    if (has_welcome_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->welcome_text());
    }

    // optional uint64 permissions = 4;
    if (has_permissions()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->permissions());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ServerSync::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ServerSync*>(&from));
}

void ServerSync::MergeFrom(const ServerSync& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_max_bandwidth()) {
      set_max_bandwidth(from.max_bandwidth());
    }
    if (from.has_welcome_text()) {
      set_has_welcome_text();
      welcome_text_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.welcome_text_);
    }
    if (from.has_permissions()) {
      set_permissions(from.permissions());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ServerSync::CopyFrom(const ServerSync& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ServerSync::IsInitialized() const {

  return true;
}

void ServerSync::Swap(ServerSync* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ServerSync::InternalSwap(ServerSync* other) {
  std::swap(session_, other->session_);
  std::swap(max_bandwidth_, other->max_bandwidth_);
  welcome_text_.Swap(&other->welcome_text_);
  std::swap(permissions_, other->permissions_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ServerSync::GetTypeName() const {
  return "MumbleProto.ServerSync";
}


// ===================================================================

#ifndef _MSC_VER
const int ChannelRemove::kChannelIdFieldNumber;
#endif  // !_MSC_VER

ChannelRemove::ChannelRemove()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ChannelRemove)
}

void ChannelRemove::InitAsDefaultInstance() {
}

ChannelRemove::ChannelRemove(const ChannelRemove& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ChannelRemove)
}

void ChannelRemove::SharedCtor() {
  _cached_size_ = 0;
  channel_id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChannelRemove::~ChannelRemove() {
  // @@protoc_insertion_point(destructor:MumbleProto.ChannelRemove)
  SharedDtor();
}

void ChannelRemove::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ChannelRemove::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChannelRemove& ChannelRemove::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ChannelRemove* ChannelRemove::default_instance_ = NULL;

ChannelRemove* ChannelRemove::New(::google::protobuf::Arena* arena) const {
  ChannelRemove* n = new ChannelRemove;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ChannelRemove::Clear() {
  channel_id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ChannelRemove::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ChannelRemove)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 channel_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ChannelRemove)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ChannelRemove)
  return false;
#undef DO_
}

void ChannelRemove::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ChannelRemove)
  // required uint32 channel_id = 1;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->channel_id(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ChannelRemove)
}

int ChannelRemove::ByteSize() const {
  int total_size = 0;

  // required uint32 channel_id = 1;
  if (has_channel_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->channel_id());
  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChannelRemove::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChannelRemove*>(&from));
}

void ChannelRemove::MergeFrom(const ChannelRemove& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ChannelRemove::CopyFrom(const ChannelRemove& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChannelRemove::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ChannelRemove::Swap(ChannelRemove* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ChannelRemove::InternalSwap(ChannelRemove* other) {
  std::swap(channel_id_, other->channel_id_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ChannelRemove::GetTypeName() const {
  return "MumbleProto.ChannelRemove";
}


// ===================================================================

#ifndef _MSC_VER
const int ChannelState::kChannelIdFieldNumber;
const int ChannelState::kParentFieldNumber;
const int ChannelState::kNameFieldNumber;
const int ChannelState::kLinksFieldNumber;
const int ChannelState::kDescriptionFieldNumber;
const int ChannelState::kLinksAddFieldNumber;
const int ChannelState::kLinksRemoveFieldNumber;
const int ChannelState::kTemporaryFieldNumber;
const int ChannelState::kPositionFieldNumber;
const int ChannelState::kDescriptionHashFieldNumber;
#endif  // !_MSC_VER

ChannelState::ChannelState()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ChannelState)
}

void ChannelState::InitAsDefaultInstance() {
}

ChannelState::ChannelState(const ChannelState& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ChannelState)
}

void ChannelState::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  channel_id_ = 0u;
  parent_ = 0u;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  temporary_ = false;
  position_ = 0;
  description_hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChannelState::~ChannelState() {
  // @@protoc_insertion_point(destructor:MumbleProto.ChannelState)
  SharedDtor();
}

void ChannelState::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  description_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  description_hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ChannelState::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChannelState& ChannelState::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ChannelState* ChannelState::default_instance_ = NULL;

ChannelState* ChannelState::New(::google::protobuf::Arena* arena) const {
  ChannelState* n = new ChannelState;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ChannelState::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ChannelState*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 151) {
    ZR_(channel_id_, parent_);
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_description()) {
      description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    temporary_ = false;
  }
  if (_has_bits_[8 / 32] & 768) {
    position_ = 0;
    if (has_description_hash()) {
      description_hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  links_.Clear();
  links_add_.Clear();
  links_remove_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ChannelState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ChannelState)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 channel_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_parent;
        break;
      }

      // optional uint32 parent = 2;
      case 2: {
        if (tag == 16) {
         parse_parent:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &parent_)));
          set_has_parent();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

      // optional string name = 3;
      case 3: {
        if (tag == 26) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_links;
        break;
      }

      // repeated uint32 links = 4;
      case 4: {
        if (tag == 32) {
         parse_links:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 32, input, this->mutable_links())));
        } else if (tag == 34) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_links())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_links;
        if (input->ExpectTag(42)) goto parse_description;
        break;
      }

      // optional string description = 5;
      case 5: {
        if (tag == 42) {
         parse_description:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_description()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_links_add;
        break;
      }

      // repeated uint32 links_add = 6;
      case 6: {
        if (tag == 48) {
         parse_links_add:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 48, input, this->mutable_links_add())));
        } else if (tag == 50) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_links_add())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_links_add;
        if (input->ExpectTag(56)) goto parse_links_remove;
        break;
      }

      // repeated uint32 links_remove = 7;
      case 7: {
        if (tag == 56) {
         parse_links_remove:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 56, input, this->mutable_links_remove())));
        } else if (tag == 58) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_links_remove())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_links_remove;
        if (input->ExpectTag(64)) goto parse_temporary;
        break;
      }

      // optional bool temporary = 8 [default = false];
      case 8: {
        if (tag == 64) {
         parse_temporary:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &temporary_)));
          set_has_temporary();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_position;
        break;
      }

      // optional int32 position = 9 [default = 0];
      case 9: {
        if (tag == 72) {
         parse_position:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &position_)));
          set_has_position();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(82)) goto parse_description_hash;
        break;
      }

      // optional bytes description_hash = 10;
      case 10: {
        if (tag == 82) {
         parse_description_hash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_description_hash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ChannelState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ChannelState)
  return false;
#undef DO_
}

void ChannelState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ChannelState)
  // optional uint32 channel_id = 1;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->channel_id(), output);
  }

  // optional uint32 parent = 2;
  if (has_parent()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->parent(), output);
  }

  // optional string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->name(), output);
  }

  // repeated uint32 links = 4;
  for (int i = 0; i < this->links_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      4, this->links(i), output);
  }

  // optional string description = 5;
  if (has_description()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->description(), output);
  }

  // repeated uint32 links_add = 6;
  for (int i = 0; i < this->links_add_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      6, this->links_add(i), output);
  }

  // repeated uint32 links_remove = 7;
  for (int i = 0; i < this->links_remove_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      7, this->links_remove(i), output);
  }

  // optional bool temporary = 8 [default = false];
  if (has_temporary()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->temporary(), output);
  }

  // optional int32 position = 9 [default = 0];
  if (has_position()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->position(), output);
  }

  // optional bytes description_hash = 10;
  if (has_description_hash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      10, this->description_hash(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ChannelState)
}

int ChannelState::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 151) {
    // optional uint32 channel_id = 1;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

    // optional uint32 parent = 2;
    if (has_parent()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->parent());
    }

    // optional string name = 3;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string description = 5;
    if (has_description()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->description());
    }

    // optional bool temporary = 8 [default = false];
    if (has_temporary()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & 768) {
    // optional int32 position = 9 [default = 0];
    if (has_position()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->position());
    }

    // optional bytes description_hash = 10;
    if (has_description_hash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->description_hash());
    }

  }
  // repeated uint32 links = 4;
  {
    int data_size = 0;
    for (int i = 0; i < this->links_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->links(i));
    }
    total_size += 1 * this->links_size() + data_size;
  }

  // repeated uint32 links_add = 6;
  {
    int data_size = 0;
    for (int i = 0; i < this->links_add_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->links_add(i));
    }
    total_size += 1 * this->links_add_size() + data_size;
  }

  // repeated uint32 links_remove = 7;
  {
    int data_size = 0;
    for (int i = 0; i < this->links_remove_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->links_remove(i));
    }
    total_size += 1 * this->links_remove_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChannelState::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChannelState*>(&from));
}

void ChannelState::MergeFrom(const ChannelState& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  links_.MergeFrom(from.links_);
  links_add_.MergeFrom(from.links_add_);
  links_remove_.MergeFrom(from.links_remove_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_parent()) {
      set_parent(from.parent());
    }
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (from.has_description()) {
      set_has_description();
      description_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.description_);
    }
    if (from.has_temporary()) {
      set_temporary(from.temporary());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_position()) {
      set_position(from.position());
    }
    if (from.has_description_hash()) {
      set_has_description_hash();
      description_hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.description_hash_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ChannelState::CopyFrom(const ChannelState& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChannelState::IsInitialized() const {

  return true;
}

void ChannelState::Swap(ChannelState* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ChannelState::InternalSwap(ChannelState* other) {
  std::swap(channel_id_, other->channel_id_);
  std::swap(parent_, other->parent_);
  name_.Swap(&other->name_);
  links_.UnsafeArenaSwap(&other->links_);
  description_.Swap(&other->description_);
  links_add_.UnsafeArenaSwap(&other->links_add_);
  links_remove_.UnsafeArenaSwap(&other->links_remove_);
  std::swap(temporary_, other->temporary_);
  std::swap(position_, other->position_);
  description_hash_.Swap(&other->description_hash_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ChannelState::GetTypeName() const {
  return "MumbleProto.ChannelState";
}


// ===================================================================

#ifndef _MSC_VER
const int UserRemove::kSessionFieldNumber;
const int UserRemove::kActorFieldNumber;
const int UserRemove::kReasonFieldNumber;
const int UserRemove::kBanFieldNumber;
#endif  // !_MSC_VER

UserRemove::UserRemove()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserRemove)
}

void UserRemove::InitAsDefaultInstance() {
}

UserRemove::UserRemove(const UserRemove& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserRemove)
}

void UserRemove::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  session_ = 0u;
  actor_ = 0u;
  reason_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ban_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserRemove::~UserRemove() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserRemove)
  SharedDtor();
}

void UserRemove::SharedDtor() {
  reason_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UserRemove::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserRemove& UserRemove::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserRemove* UserRemove::default_instance_ = NULL;

UserRemove* UserRemove::New(::google::protobuf::Arena* arena) const {
  UserRemove* n = new UserRemove;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserRemove::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<UserRemove*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(session_, actor_);
    if (has_reason()) {
      reason_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    ban_ = false;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserRemove::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserRemove)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 session = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_actor;
        break;
      }

      // optional uint32 actor = 2;
      case 2: {
        if (tag == 16) {
         parse_actor:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &actor_)));
          set_has_actor();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_reason;
        break;
      }

      // optional string reason = 3;
      case 3: {
        if (tag == 26) {
         parse_reason:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_reason()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_ban;
        break;
      }

      // optional bool ban = 4;
      case 4: {
        if (tag == 32) {
         parse_ban:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ban_)));
          set_has_ban();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserRemove)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserRemove)
  return false;
#undef DO_
}

void UserRemove::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserRemove)
  // required uint32 session = 1;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->session(), output);
  }

  // optional uint32 actor = 2;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->actor(), output);
  }

  // optional string reason = 3;
  if (has_reason()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->reason(), output);
  }

  // optional bool ban = 4;
  if (has_ban()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->ban(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserRemove)
}

int UserRemove::ByteSize() const {
  int total_size = 0;

  // required uint32 session = 1;
  if (has_session()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->session());
  }
  if (_has_bits_[1 / 32] & 14) {
    // optional uint32 actor = 2;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->actor());
    }

    // optional string reason = 3;
    if (has_reason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->reason());
    }

    // optional bool ban = 4;
    if (has_ban()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserRemove::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserRemove*>(&from));
}

void UserRemove::MergeFrom(const UserRemove& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_actor()) {
      set_actor(from.actor());
    }
    if (from.has_reason()) {
      set_has_reason();
      reason_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reason_);
    }
    if (from.has_ban()) {
      set_ban(from.ban());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserRemove::CopyFrom(const UserRemove& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserRemove::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void UserRemove::Swap(UserRemove* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserRemove::InternalSwap(UserRemove* other) {
  std::swap(session_, other->session_);
  std::swap(actor_, other->actor_);
  reason_.Swap(&other->reason_);
  std::swap(ban_, other->ban_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserRemove::GetTypeName() const {
  return "MumbleProto.UserRemove";
}


// ===================================================================

#ifndef _MSC_VER
const int UserState::kSessionFieldNumber;
const int UserState::kActorFieldNumber;
const int UserState::kNameFieldNumber;
const int UserState::kUserIdFieldNumber;
const int UserState::kChannelIdFieldNumber;
const int UserState::kMuteFieldNumber;
const int UserState::kDeafFieldNumber;
const int UserState::kSuppressFieldNumber;
const int UserState::kSelfMuteFieldNumber;
const int UserState::kSelfDeafFieldNumber;
const int UserState::kTextureFieldNumber;
const int UserState::kPluginContextFieldNumber;
const int UserState::kPluginIdentityFieldNumber;
const int UserState::kCommentFieldNumber;
const int UserState::kHashFieldNumber;
const int UserState::kCommentHashFieldNumber;
const int UserState::kTextureHashFieldNumber;
const int UserState::kPrioritySpeakerFieldNumber;
const int UserState::kRecordingFieldNumber;
#endif  // !_MSC_VER

UserState::UserState()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserState)
}

void UserState::InitAsDefaultInstance() {
}

UserState::UserState(const UserState& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserState)
}

void UserState::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  session_ = 0u;
  actor_ = 0u;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  user_id_ = 0u;
  channel_id_ = 0u;
  mute_ = false;
  deaf_ = false;
  suppress_ = false;
  self_mute_ = false;
  self_deaf_ = false;
  texture_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  plugin_context_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  plugin_identity_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  comment_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  comment_hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  texture_hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  priority_speaker_ = false;
  recording_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserState::~UserState() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserState)
  SharedDtor();
}

void UserState::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  texture_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  plugin_context_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  plugin_identity_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  comment_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  comment_hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  texture_hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UserState::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserState& UserState::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserState* UserState::default_instance_ = NULL;

UserState* UserState::New(::google::protobuf::Arena* arena) const {
  UserState* n = new UserState;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserState::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<UserState*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(session_, actor_);
    ZR_(user_id_, channel_id_);
    ZR_(mute_, suppress_);
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  if (_has_bits_[8 / 32] & 65280) {
    ZR_(self_mute_, self_deaf_);
    if (has_texture()) {
      texture_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_plugin_context()) {
      plugin_context_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_plugin_identity()) {
      plugin_identity_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_comment()) {
      comment_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_hash()) {
      hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_comment_hash()) {
      comment_hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  if (_has_bits_[16 / 32] & 458752) {
    ZR_(priority_speaker_, recording_);
    if (has_texture_hash()) {
      texture_hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserState)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 session = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_actor;
        break;
      }

      // optional uint32 actor = 2;
      case 2: {
        if (tag == 16) {
         parse_actor:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &actor_)));
          set_has_actor();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

      // optional string name = 3;
      case 3: {
        if (tag == 26) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_user_id;
        break;
      }

      // optional uint32 user_id = 4;
      case 4: {
        if (tag == 32) {
         parse_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_channel_id;
        break;
      }

      // optional uint32 channel_id = 5;
      case 5: {
        if (tag == 40) {
         parse_channel_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_mute;
        break;
      }

      // optional bool mute = 6;
      case 6: {
        if (tag == 48) {
         parse_mute:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mute_)));
          set_has_mute();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_deaf;
        break;
      }

      // optional bool deaf = 7;
      case 7: {
        if (tag == 56) {
         parse_deaf:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &deaf_)));
          set_has_deaf();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_suppress;
        break;
      }

      // optional bool suppress = 8;
      case 8: {
        if (tag == 64) {
         parse_suppress:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &suppress_)));
          set_has_suppress();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_self_mute;
        break;
      }

      // optional bool self_mute = 9;
      case 9: {
        if (tag == 72) {
         parse_self_mute:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &self_mute_)));
          set_has_self_mute();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_self_deaf;
        break;
      }

      // optional bool self_deaf = 10;
      case 10: {
        if (tag == 80) {
         parse_self_deaf:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &self_deaf_)));
          set_has_self_deaf();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(90)) goto parse_texture;
        break;
      }

      // optional bytes texture = 11;
      case 11: {
        if (tag == 90) {
         parse_texture:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_texture()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(98)) goto parse_plugin_context;
        break;
      }

      // optional bytes plugin_context = 12;
      case 12: {
        if (tag == 98) {
         parse_plugin_context:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_plugin_context()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(106)) goto parse_plugin_identity;
        break;
      }

      // optional string plugin_identity = 13;
      case 13: {
        if (tag == 106) {
         parse_plugin_identity:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_plugin_identity()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(114)) goto parse_comment;
        break;
      }

      // optional string comment = 14;
      case 14: {
        if (tag == 114) {
         parse_comment:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_comment()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(122)) goto parse_hash;
        break;
      }

      // optional string hash = 15;
      case 15: {
        if (tag == 122) {
         parse_hash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_hash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(130)) goto parse_comment_hash;
        break;
      }

      // optional bytes comment_hash = 16;
      case 16: {
        if (tag == 130) {
         parse_comment_hash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_comment_hash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(138)) goto parse_texture_hash;
        break;
      }

      // optional bytes texture_hash = 17;
      case 17: {
        if (tag == 138) {
         parse_texture_hash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_texture_hash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(144)) goto parse_priority_speaker;
        break;
      }

      // optional bool priority_speaker = 18;
      case 18: {
        if (tag == 144) {
         parse_priority_speaker:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &priority_speaker_)));
          set_has_priority_speaker();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(152)) goto parse_recording;
        break;
      }

      // optional bool recording = 19;
      case 19: {
        if (tag == 152) {
         parse_recording:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &recording_)));
          set_has_recording();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserState)
  return false;
#undef DO_
}

void UserState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserState)
  // optional uint32 session = 1;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->session(), output);
  }

  // optional uint32 actor = 2;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->actor(), output);
  }

  // optional string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->name(), output);
  }

  // optional uint32 user_id = 4;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->user_id(), output);
  }

  // optional uint32 channel_id = 5;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->channel_id(), output);
  }

  // optional bool mute = 6;
  if (has_mute()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mute(), output);
  }

  // optional bool deaf = 7;
  if (has_deaf()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->deaf(), output);
  }

  // optional bool suppress = 8;
  if (has_suppress()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->suppress(), output);
  }

  // optional bool self_mute = 9;
  if (has_self_mute()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->self_mute(), output);
  }

  // optional bool self_deaf = 10;
  if (has_self_deaf()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->self_deaf(), output);
  }

  // optional bytes texture = 11;
  if (has_texture()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      11, this->texture(), output);
  }

  // optional bytes plugin_context = 12;
  if (has_plugin_context()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      12, this->plugin_context(), output);
  }

  // optional string plugin_identity = 13;
  if (has_plugin_identity()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      13, this->plugin_identity(), output);
  }

  // optional string comment = 14;
  if (has_comment()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      14, this->comment(), output);
  }

  // optional string hash = 15;
  if (has_hash()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      15, this->hash(), output);
  }

  // optional bytes comment_hash = 16;
  if (has_comment_hash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      16, this->comment_hash(), output);
  }

  // optional bytes texture_hash = 17;
  if (has_texture_hash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      17, this->texture_hash(), output);
  }

  // optional bool priority_speaker = 18;
  if (has_priority_speaker()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->priority_speaker(), output);
  }

  // optional bool recording = 19;
  if (has_recording()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->recording(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserState)
}

int UserState::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 255) {
    // optional uint32 session = 1;
    if (has_session()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->session());
    }

    // optional uint32 actor = 2;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->actor());
    }

    // optional string name = 3;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional uint32 user_id = 4;
    if (has_user_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->user_id());
    }

    // optional uint32 channel_id = 5;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

    // optional bool mute = 6;
    if (has_mute()) {
      total_size += 1 + 1;
    }

    // optional bool deaf = 7;
    if (has_deaf()) {
      total_size += 1 + 1;
    }

    // optional bool suppress = 8;
    if (has_suppress()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & 65280) {
    // optional bool self_mute = 9;
    if (has_self_mute()) {
      total_size += 1 + 1;
    }

    // optional bool self_deaf = 10;
    if (has_self_deaf()) {
      total_size += 1 + 1;
    }

    // optional bytes texture = 11;
    if (has_texture()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->texture());
    }

    // optional bytes plugin_context = 12;
    if (has_plugin_context()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->plugin_context());
    }

    // optional string plugin_identity = 13;
    if (has_plugin_identity()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->plugin_identity());
    }

    // optional string comment = 14;
    if (has_comment()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->comment());
    }

    // optional string hash = 15;
    if (has_hash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->hash());
    }

    // optional bytes comment_hash = 16;
    if (has_comment_hash()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->comment_hash());
    }

  }
  if (_has_bits_[16 / 32] & 458752) {
    // optional bytes texture_hash = 17;
    if (has_texture_hash()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->texture_hash());
    }

    // optional bool priority_speaker = 18;
    if (has_priority_speaker()) {
      total_size += 2 + 1;
    }

    // optional bool recording = 19;
    if (has_recording()) {
      total_size += 2 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserState::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserState*>(&from));
}

void UserState::MergeFrom(const UserState& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_actor()) {
      set_actor(from.actor());
    }
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_mute()) {
      set_mute(from.mute());
    }
    if (from.has_deaf()) {
      set_deaf(from.deaf());
    }
    if (from.has_suppress()) {
      set_suppress(from.suppress());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_self_mute()) {
      set_self_mute(from.self_mute());
    }
    if (from.has_self_deaf()) {
      set_self_deaf(from.self_deaf());
    }
    if (from.has_texture()) {
      set_has_texture();
      texture_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.texture_);
    }
    if (from.has_plugin_context()) {
      set_has_plugin_context();
      plugin_context_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.plugin_context_);
    }
    if (from.has_plugin_identity()) {
      set_has_plugin_identity();
      plugin_identity_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.plugin_identity_);
    }
    if (from.has_comment()) {
      set_has_comment();
      comment_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.comment_);
    }
    if (from.has_hash()) {
      set_has_hash();
      hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.hash_);
    }
    if (from.has_comment_hash()) {
      set_has_comment_hash();
      comment_hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.comment_hash_);
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_texture_hash()) {
      set_has_texture_hash();
      texture_hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.texture_hash_);
    }
    if (from.has_priority_speaker()) {
      set_priority_speaker(from.priority_speaker());
    }
    if (from.has_recording()) {
      set_recording(from.recording());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserState::CopyFrom(const UserState& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserState::IsInitialized() const {

  return true;
}

void UserState::Swap(UserState* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserState::InternalSwap(UserState* other) {
  std::swap(session_, other->session_);
  std::swap(actor_, other->actor_);
  name_.Swap(&other->name_);
  std::swap(user_id_, other->user_id_);
  std::swap(channel_id_, other->channel_id_);
  std::swap(mute_, other->mute_);
  std::swap(deaf_, other->deaf_);
  std::swap(suppress_, other->suppress_);
  std::swap(self_mute_, other->self_mute_);
  std::swap(self_deaf_, other->self_deaf_);
  texture_.Swap(&other->texture_);
  plugin_context_.Swap(&other->plugin_context_);
  plugin_identity_.Swap(&other->plugin_identity_);
  comment_.Swap(&other->comment_);
  hash_.Swap(&other->hash_);
  comment_hash_.Swap(&other->comment_hash_);
  texture_hash_.Swap(&other->texture_hash_);
  std::swap(priority_speaker_, other->priority_speaker_);
  std::swap(recording_, other->recording_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserState::GetTypeName() const {
  return "MumbleProto.UserState";
}


// ===================================================================

#ifndef _MSC_VER
const int BanList_BanEntry::kAddressFieldNumber;
const int BanList_BanEntry::kMaskFieldNumber;
const int BanList_BanEntry::kNameFieldNumber;
const int BanList_BanEntry::kHashFieldNumber;
const int BanList_BanEntry::kReasonFieldNumber;
const int BanList_BanEntry::kStartFieldNumber;
const int BanList_BanEntry::kDurationFieldNumber;
#endif  // !_MSC_VER

BanList_BanEntry::BanList_BanEntry()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.BanList.BanEntry)
}

void BanList_BanEntry::InitAsDefaultInstance() {
}

BanList_BanEntry::BanList_BanEntry(const BanList_BanEntry& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.BanList.BanEntry)
}

void BanList_BanEntry::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  address_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mask_ = 0u;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  reason_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  start_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  duration_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

BanList_BanEntry::~BanList_BanEntry() {
  // @@protoc_insertion_point(destructor:MumbleProto.BanList.BanEntry)
  SharedDtor();
}

void BanList_BanEntry::SharedDtor() {
  address_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  reason_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  start_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void BanList_BanEntry::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const BanList_BanEntry& BanList_BanEntry::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

BanList_BanEntry* BanList_BanEntry::default_instance_ = NULL;

BanList_BanEntry* BanList_BanEntry::New(::google::protobuf::Arena* arena) const {
  BanList_BanEntry* n = new BanList_BanEntry;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BanList_BanEntry::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<BanList_BanEntry*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 127) {
    ZR_(mask_, duration_);
    if (has_address()) {
      address_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_hash()) {
      hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_reason()) {
      reason_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_start()) {
      start_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool BanList_BanEntry::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.BanList.BanEntry)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes address = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_address()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_mask;
        break;
      }

      // required uint32 mask = 2;
      case 2: {
        if (tag == 16) {
         parse_mask:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &mask_)));
          set_has_mask();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

      // optional string name = 3;
      case 3: {
        if (tag == 26) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_hash;
        break;
      }

      // optional string hash = 4;
      case 4: {
        if (tag == 34) {
         parse_hash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_hash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_reason;
        break;
      }

      // optional string reason = 5;
      case 5: {
        if (tag == 42) {
         parse_reason:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_reason()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_start;
        break;
      }

      // optional string start = 6;
      case 6: {
        if (tag == 50) {
         parse_start:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_start()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_duration;
        break;
      }

      // optional uint32 duration = 7;
      case 7: {
        if (tag == 56) {
         parse_duration:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &duration_)));
          set_has_duration();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.BanList.BanEntry)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.BanList.BanEntry)
  return false;
#undef DO_
}

void BanList_BanEntry::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.BanList.BanEntry)
  // required bytes address = 1;
  if (has_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->address(), output);
  }

  // required uint32 mask = 2;
  if (has_mask()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->mask(), output);
  }

  // optional string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->name(), output);
  }

  // optional string hash = 4;
  if (has_hash()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->hash(), output);
  }

  // optional string reason = 5;
  if (has_reason()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->reason(), output);
  }

  // optional string start = 6;
  if (has_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->start(), output);
  }

  // optional uint32 duration = 7;
  if (has_duration()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->duration(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.BanList.BanEntry)
}

int BanList_BanEntry::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_address()) {
    // required bytes address = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->address());
  }

  if (has_mask()) {
    // required uint32 mask = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->mask());
  }

  return total_size;
}
int BanList_BanEntry::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required bytes address = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->address());

    // required uint32 mask = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->mask());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_has_bits_[2 / 32] & 124) {
    // optional string name = 3;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string hash = 4;
    if (has_hash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->hash());
    }

    // optional string reason = 5;
    if (has_reason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->reason());
    }

    // optional string start = 6;
    if (has_start()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->start());
    }

    // optional uint32 duration = 7;
    if (has_duration()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->duration());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BanList_BanEntry::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const BanList_BanEntry*>(&from));
}

void BanList_BanEntry::MergeFrom(const BanList_BanEntry& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_address()) {
      set_has_address();
      address_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.address_);
    }
    if (from.has_mask()) {
      set_mask(from.mask());
    }
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (from.has_hash()) {
      set_has_hash();
      hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.hash_);
    }
    if (from.has_reason()) {
      set_has_reason();
      reason_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reason_);
    }
    if (from.has_start()) {
      set_has_start();
      start_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_);
    }
    if (from.has_duration()) {
      set_duration(from.duration());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void BanList_BanEntry::CopyFrom(const BanList_BanEntry& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BanList_BanEntry::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void BanList_BanEntry::Swap(BanList_BanEntry* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BanList_BanEntry::InternalSwap(BanList_BanEntry* other) {
  address_.Swap(&other->address_);
  std::swap(mask_, other->mask_);
  name_.Swap(&other->name_);
  hash_.Swap(&other->hash_);
  reason_.Swap(&other->reason_);
  start_.Swap(&other->start_);
  std::swap(duration_, other->duration_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string BanList_BanEntry::GetTypeName() const {
  return "MumbleProto.BanList.BanEntry";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int BanList::kBansFieldNumber;
const int BanList::kQueryFieldNumber;
#endif  // !_MSC_VER

BanList::BanList()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.BanList)
}

void BanList::InitAsDefaultInstance() {
}

BanList::BanList(const BanList& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.BanList)
}

void BanList::SharedCtor() {
  _cached_size_ = 0;
  query_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

BanList::~BanList() {
  // @@protoc_insertion_point(destructor:MumbleProto.BanList)
  SharedDtor();
}

void BanList::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void BanList::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const BanList& BanList::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

BanList* BanList::default_instance_ = NULL;

BanList* BanList::New(::google::protobuf::Arena* arena) const {
  BanList* n = new BanList;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BanList::Clear() {
  query_ = false;
  bans_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool BanList::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.BanList)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .MumbleProto.BanList.BanEntry bans = 1;
      case 1: {
        if (tag == 10) {
         parse_bans:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_bans()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_bans;
        if (input->ExpectTag(16)) goto parse_query;
        break;
      }

      // optional bool query = 2 [default = false];
      case 2: {
        if (tag == 16) {
         parse_query:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &query_)));
          set_has_query();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.BanList)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.BanList)
  return false;
#undef DO_
}

void BanList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.BanList)
  // repeated .MumbleProto.BanList.BanEntry bans = 1;
  for (unsigned int i = 0, n = this->bans_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->bans(i), output);
  }

  // optional bool query = 2 [default = false];
  if (has_query()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->query(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.BanList)
}

int BanList::ByteSize() const {
  int total_size = 0;

  // optional bool query = 2 [default = false];
  if (has_query()) {
    total_size += 1 + 1;
  }

  // repeated .MumbleProto.BanList.BanEntry bans = 1;
  total_size += 1 * this->bans_size();
  for (int i = 0; i < this->bans_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->bans(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BanList::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const BanList*>(&from));
}

void BanList::MergeFrom(const BanList& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  bans_.MergeFrom(from.bans_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_query()) {
      set_query(from.query());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void BanList::CopyFrom(const BanList& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BanList::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->bans())) return false;
  return true;
}

void BanList::Swap(BanList* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BanList::InternalSwap(BanList* other) {
  bans_.UnsafeArenaSwap(&other->bans_);
  std::swap(query_, other->query_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string BanList::GetTypeName() const {
  return "MumbleProto.BanList";
}


// ===================================================================

#ifndef _MSC_VER
const int TextMessage::kActorFieldNumber;
const int TextMessage::kSessionFieldNumber;
const int TextMessage::kChannelIdFieldNumber;
const int TextMessage::kTreeIdFieldNumber;
const int TextMessage::kMessageFieldNumber;
#endif  // !_MSC_VER

TextMessage::TextMessage()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.TextMessage)
}

void TextMessage::InitAsDefaultInstance() {
}

TextMessage::TextMessage(const TextMessage& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.TextMessage)
}

void TextMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  actor_ = 0u;
  message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

TextMessage::~TextMessage() {
  // @@protoc_insertion_point(destructor:MumbleProto.TextMessage)
  SharedDtor();
}

void TextMessage::SharedDtor() {
  message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void TextMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const TextMessage& TextMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

TextMessage* TextMessage::default_instance_ = NULL;

TextMessage* TextMessage::New(::google::protobuf::Arena* arena) const {
  TextMessage* n = new TextMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TextMessage::Clear() {
  if (_has_bits_[0 / 32] & 17) {
    actor_ = 0u;
    if (has_message()) {
      message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  session_.Clear();
  channel_id_.Clear();
  tree_id_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool TextMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.TextMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 actor = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &actor_)));
          set_has_actor();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_session;
        break;
      }

      // repeated uint32 session = 2;
      case 2: {
        if (tag == 16) {
         parse_session:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 16, input, this->mutable_session())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_session())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_session;
        if (input->ExpectTag(24)) goto parse_channel_id;
        break;
      }

      // repeated uint32 channel_id = 3;
      case 3: {
        if (tag == 24) {
         parse_channel_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 24, input, this->mutable_channel_id())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_channel_id())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_channel_id;
        if (input->ExpectTag(32)) goto parse_tree_id;
        break;
      }

      // repeated uint32 tree_id = 4;
      case 4: {
        if (tag == 32) {
         parse_tree_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 32, input, this->mutable_tree_id())));
        } else if (tag == 34) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_tree_id())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_tree_id;
        if (input->ExpectTag(42)) goto parse_message;
        break;
      }

      // required string message = 5;
      case 5: {
        if (tag == 42) {
         parse_message:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_message()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.TextMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.TextMessage)
  return false;
#undef DO_
}

void TextMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.TextMessage)
  // optional uint32 actor = 1;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->actor(), output);
  }

  // repeated uint32 session = 2;
  for (int i = 0; i < this->session_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      2, this->session(i), output);
  }

  // repeated uint32 channel_id = 3;
  for (int i = 0; i < this->channel_id_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      3, this->channel_id(i), output);
  }

  // repeated uint32 tree_id = 4;
  for (int i = 0; i < this->tree_id_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      4, this->tree_id(i), output);
  }

  // required string message = 5;
  if (has_message()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->message(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.TextMessage)
}

int TextMessage::ByteSize() const {
  int total_size = 0;

  // required string message = 5;
  if (has_message()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->message());
  }
  // optional uint32 actor = 1;
  if (has_actor()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->actor());
  }

  // repeated uint32 session = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->session_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->session(i));
    }
    total_size += 1 * this->session_size() + data_size;
  }

  // repeated uint32 channel_id = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->channel_id_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->channel_id(i));
    }
    total_size += 1 * this->channel_id_size() + data_size;
  }

  // repeated uint32 tree_id = 4;
  {
    int data_size = 0;
    for (int i = 0; i < this->tree_id_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->tree_id(i));
    }
    total_size += 1 * this->tree_id_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TextMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const TextMessage*>(&from));
}

void TextMessage::MergeFrom(const TextMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  session_.MergeFrom(from.session_);
  channel_id_.MergeFrom(from.channel_id_);
  tree_id_.MergeFrom(from.tree_id_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_actor()) {
      set_actor(from.actor());
    }
    if (from.has_message()) {
      set_has_message();
      message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void TextMessage::CopyFrom(const TextMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TextMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000010) != 0x00000010) return false;

  return true;
}

void TextMessage::Swap(TextMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TextMessage::InternalSwap(TextMessage* other) {
  std::swap(actor_, other->actor_);
  session_.UnsafeArenaSwap(&other->session_);
  channel_id_.UnsafeArenaSwap(&other->channel_id_);
  tree_id_.UnsafeArenaSwap(&other->tree_id_);
  message_.Swap(&other->message_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string TextMessage::GetTypeName() const {
  return "MumbleProto.TextMessage";
}


// ===================================================================

bool PermissionDenied_DenyType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const PermissionDenied_DenyType PermissionDenied::Text;
const PermissionDenied_DenyType PermissionDenied::Permission;
const PermissionDenied_DenyType PermissionDenied::SuperUser;
const PermissionDenied_DenyType PermissionDenied::ChannelName;
const PermissionDenied_DenyType PermissionDenied::TextTooLong;
const PermissionDenied_DenyType PermissionDenied::H9K;
const PermissionDenied_DenyType PermissionDenied::TemporaryChannel;
const PermissionDenied_DenyType PermissionDenied::MissingCertificate;
const PermissionDenied_DenyType PermissionDenied::UserName;
const PermissionDenied_DenyType PermissionDenied::ChannelFull;
const PermissionDenied_DenyType PermissionDenied::NestingLimit;
const PermissionDenied_DenyType PermissionDenied::DenyType_MIN;
const PermissionDenied_DenyType PermissionDenied::DenyType_MAX;
const int PermissionDenied::DenyType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int PermissionDenied::kPermissionFieldNumber;
const int PermissionDenied::kChannelIdFieldNumber;
const int PermissionDenied::kSessionFieldNumber;
const int PermissionDenied::kReasonFieldNumber;
const int PermissionDenied::kTypeFieldNumber;
const int PermissionDenied::kNameFieldNumber;
#endif  // !_MSC_VER

PermissionDenied::PermissionDenied()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.PermissionDenied)
}

void PermissionDenied::InitAsDefaultInstance() {
}

PermissionDenied::PermissionDenied(const PermissionDenied& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.PermissionDenied)
}

void PermissionDenied::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  permission_ = 0u;
  channel_id_ = 0u;
  session_ = 0u;
  reason_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PermissionDenied::~PermissionDenied() {
  // @@protoc_insertion_point(destructor:MumbleProto.PermissionDenied)
  SharedDtor();
}

void PermissionDenied::SharedDtor() {
  reason_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PermissionDenied::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PermissionDenied& PermissionDenied::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

PermissionDenied* PermissionDenied::default_instance_ = NULL;

PermissionDenied* PermissionDenied::New(::google::protobuf::Arena* arena) const {
  PermissionDenied* n = new PermissionDenied;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PermissionDenied::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PermissionDenied*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(permission_, channel_id_);
    ZR_(session_, type_);
    if (has_reason()) {
      reason_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PermissionDenied::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.PermissionDenied)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 permission = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &permission_)));
          set_has_permission();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_channel_id;
        break;
      }

      // optional uint32 channel_id = 2;
      case 2: {
        if (tag == 16) {
         parse_channel_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_session;
        break;
      }

      // optional uint32 session = 3;
      case 3: {
        if (tag == 24) {
         parse_session:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_reason;
        break;
      }

      // optional string reason = 4;
      case 4: {
        if (tag == 34) {
         parse_reason:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_reason()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_type;
        break;
      }

      // optional .MumbleProto.PermissionDenied.DenyType type = 5;
      case 5: {
        if (tag == 40) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::MumbleProto::PermissionDenied_DenyType_IsValid(value)) {
            set_type(static_cast< ::MumbleProto::PermissionDenied_DenyType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_name;
        break;
      }

      // optional string name = 6;
      case 6: {
        if (tag == 50) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.PermissionDenied)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.PermissionDenied)
  return false;
#undef DO_
}

void PermissionDenied::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.PermissionDenied)
  // optional uint32 permission = 1;
  if (has_permission()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->permission(), output);
  }

  // optional uint32 channel_id = 2;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->channel_id(), output);
  }

  // optional uint32 session = 3;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->session(), output);
  }

  // optional string reason = 4;
  if (has_reason()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->reason(), output);
  }

  // optional .MumbleProto.PermissionDenied.DenyType type = 5;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->type(), output);
  }

  // optional string name = 6;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->name(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.PermissionDenied)
}

int PermissionDenied::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 63) {
    // optional uint32 permission = 1;
    if (has_permission()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->permission());
    }

    // optional uint32 channel_id = 2;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

    // optional uint32 session = 3;
    if (has_session()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->session());
    }

    // optional string reason = 4;
    if (has_reason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->reason());
    }

    // optional .MumbleProto.PermissionDenied.DenyType type = 5;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional string name = 6;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PermissionDenied::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PermissionDenied*>(&from));
}

void PermissionDenied::MergeFrom(const PermissionDenied& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_permission()) {
      set_permission(from.permission());
    }
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_reason()) {
      set_has_reason();
      reason_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reason_);
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PermissionDenied::CopyFrom(const PermissionDenied& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PermissionDenied::IsInitialized() const {

  return true;
}

void PermissionDenied::Swap(PermissionDenied* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PermissionDenied::InternalSwap(PermissionDenied* other) {
  std::swap(permission_, other->permission_);
  std::swap(channel_id_, other->channel_id_);
  std::swap(session_, other->session_);
  reason_.Swap(&other->reason_);
  std::swap(type_, other->type_);
  name_.Swap(&other->name_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PermissionDenied::GetTypeName() const {
  return "MumbleProto.PermissionDenied";
}


// ===================================================================

#ifndef _MSC_VER
const int ACL_ChanGroup::kNameFieldNumber;
const int ACL_ChanGroup::kInheritedFieldNumber;
const int ACL_ChanGroup::kInheritFieldNumber;
const int ACL_ChanGroup::kInheritableFieldNumber;
const int ACL_ChanGroup::kAddFieldNumber;
const int ACL_ChanGroup::kRemoveFieldNumber;
const int ACL_ChanGroup::kInheritedMembersFieldNumber;
#endif  // !_MSC_VER

ACL_ChanGroup::ACL_ChanGroup()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ACL.ChanGroup)
}

void ACL_ChanGroup::InitAsDefaultInstance() {
}

ACL_ChanGroup::ACL_ChanGroup(const ACL_ChanGroup& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL.ChanGroup)
}

void ACL_ChanGroup::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  inherited_ = true;
  inherit_ = true;
  inheritable_ = true;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ACL_ChanGroup::~ACL_ChanGroup() {
  // @@protoc_insertion_point(destructor:MumbleProto.ACL.ChanGroup)
  SharedDtor();
}

void ACL_ChanGroup::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ACL_ChanGroup::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ACL_ChanGroup& ACL_ChanGroup::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ACL_ChanGroup* ACL_ChanGroup::default_instance_ = NULL;

ACL_ChanGroup* ACL_ChanGroup::New(::google::protobuf::Arena* arena) const {
  ACL_ChanGroup* n = new ACL_ChanGroup;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ACL_ChanGroup::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    inherited_ = true;
    inherit_ = true;
    inheritable_ = true;
  }
  add_.Clear();
  remove_.Clear();
  inherited_members_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ACL_ChanGroup::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ACL.ChanGroup)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_inherited;
        break;
      }

      // optional bool inherited = 2 [default = true];
      case 2: {
        if (tag == 16) {
         parse_inherited:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &inherited_)));
          set_has_inherited();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_inherit;
        break;
      }

      // optional bool inherit = 3 [default = true];
      case 3: {
        if (tag == 24) {
         parse_inherit:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &inherit_)));
          set_has_inherit();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_inheritable;
        break;
      }

      // optional bool inheritable = 4 [default = true];
      case 4: {
        if (tag == 32) {
         parse_inheritable:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &inheritable_)));
          set_has_inheritable();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_add;
        break;
      }

      // repeated uint32 add = 5;
      case 5: {
        if (tag == 40) {
         parse_add:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 40, input, this->mutable_add())));
        } else if (tag == 42) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_add())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_add;
        if (input->ExpectTag(48)) goto parse_remove;
        break;
      }

      // repeated uint32 remove = 6;
      case 6: {
        if (tag == 48) {
         parse_remove:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 48, input, this->mutable_remove())));
        } else if (tag == 50) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_remove())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_remove;
        if (input->ExpectTag(56)) goto parse_inherited_members;
        break;
      }

      // repeated uint32 inherited_members = 7;
      case 7: {
        if (tag == 56) {
         parse_inherited_members:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 56, input, this->mutable_inherited_members())));
        } else if (tag == 58) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_inherited_members())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_inherited_members;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ACL.ChanGroup)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ACL.ChanGroup)
  return false;
#undef DO_
}

void ACL_ChanGroup::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ACL.ChanGroup)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional bool inherited = 2 [default = true];
  if (has_inherited()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->inherited(), output);
  }

  // optional bool inherit = 3 [default = true];
  if (has_inherit()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->inherit(), output);
  }

  // optional bool inheritable = 4 [default = true];
  if (has_inheritable()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->inheritable(), output);
  }

  // repeated uint32 add = 5;
  for (int i = 0; i < this->add_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      5, this->add(i), output);
  }

  // repeated uint32 remove = 6;
  for (int i = 0; i < this->remove_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      6, this->remove(i), output);
  }

  // repeated uint32 inherited_members = 7;
  for (int i = 0; i < this->inherited_members_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      7, this->inherited_members(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ACL.ChanGroup)
}

int ACL_ChanGroup::ByteSize() const {
  int total_size = 0;

  // required string name = 1;
  if (has_name()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->name());
  }
  if (_has_bits_[1 / 32] & 14) {
    // optional bool inherited = 2 [default = true];
    if (has_inherited()) {
      total_size += 1 + 1;
    }

    // optional bool inherit = 3 [default = true];
    if (has_inherit()) {
      total_size += 1 + 1;
    }

    // optional bool inheritable = 4 [default = true];
    if (has_inheritable()) {
      total_size += 1 + 1;
    }

  }
  // repeated uint32 add = 5;
  {
    int data_size = 0;
    for (int i = 0; i < this->add_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->add(i));
    }
    total_size += 1 * this->add_size() + data_size;
  }

  // repeated uint32 remove = 6;
  {
    int data_size = 0;
    for (int i = 0; i < this->remove_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->remove(i));
    }
    total_size += 1 * this->remove_size() + data_size;
  }

  // repeated uint32 inherited_members = 7;
  {
    int data_size = 0;
    for (int i = 0; i < this->inherited_members_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->inherited_members(i));
    }
    total_size += 1 * this->inherited_members_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ACL_ChanGroup::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ACL_ChanGroup*>(&from));
}

void ACL_ChanGroup::MergeFrom(const ACL_ChanGroup& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  add_.MergeFrom(from.add_);
  remove_.MergeFrom(from.remove_);
  inherited_members_.MergeFrom(from.inherited_members_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (from.has_inherited()) {
      set_inherited(from.inherited());
    }
    if (from.has_inherit()) {
      set_inherit(from.inherit());
    }
    if (from.has_inheritable()) {
      set_inheritable(from.inheritable());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ACL_ChanGroup::CopyFrom(const ACL_ChanGroup& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ACL_ChanGroup::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ACL_ChanGroup::Swap(ACL_ChanGroup* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ACL_ChanGroup::InternalSwap(ACL_ChanGroup* other) {
  name_.Swap(&other->name_);
  std::swap(inherited_, other->inherited_);
  std::swap(inherit_, other->inherit_);
  std::swap(inheritable_, other->inheritable_);
  add_.UnsafeArenaSwap(&other->add_);
  remove_.UnsafeArenaSwap(&other->remove_);
  inherited_members_.UnsafeArenaSwap(&other->inherited_members_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ACL_ChanGroup::GetTypeName() const {
  return "MumbleProto.ACL.ChanGroup";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int ACL_ChanACL::kApplyHereFieldNumber;
const int ACL_ChanACL::kApplySubsFieldNumber;
const int ACL_ChanACL::kInheritedFieldNumber;
const int ACL_ChanACL::kUserIdFieldNumber;
const int ACL_ChanACL::kGroupFieldNumber;
const int ACL_ChanACL::kGrantFieldNumber;
const int ACL_ChanACL::kDenyFieldNumber;
#endif  // !_MSC_VER

ACL_ChanACL::ACL_ChanACL()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ACL.ChanACL)
}

void ACL_ChanACL::InitAsDefaultInstance() {
}

ACL_ChanACL::ACL_ChanACL(const ACL_ChanACL& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL.ChanACL)
}

void ACL_ChanACL::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  apply_here_ = true;
  apply_subs_ = true;
  inherited_ = true;
  user_id_ = 0u;
  group_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  grant_ = 0u;
  deny_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ACL_ChanACL::~ACL_ChanACL() {
  // @@protoc_insertion_point(destructor:MumbleProto.ACL.ChanACL)
  SharedDtor();
}

void ACL_ChanACL::SharedDtor() {
  group_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ACL_ChanACL::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ACL_ChanACL& ACL_ChanACL::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ACL_ChanACL* ACL_ChanACL::default_instance_ = NULL;

ACL_ChanACL* ACL_ChanACL::New(::google::protobuf::Arena* arena) const {
  ACL_ChanACL* n = new ACL_ChanACL;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ACL_ChanACL::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ACL_ChanACL*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 127) {
    ZR_(grant_, deny_);
    apply_here_ = true;
    apply_subs_ = true;
    inherited_ = true;
    user_id_ = 0u;
    if (has_group()) {
      group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ACL_ChanACL::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ACL.ChanACL)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool apply_here = 1 [default = true];
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &apply_here_)));
          set_has_apply_here();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_apply_subs;
        break;
      }

      // optional bool apply_subs = 2 [default = true];
      case 2: {
        if (tag == 16) {
         parse_apply_subs:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &apply_subs_)));
          set_has_apply_subs();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_inherited;
        break;
      }

      // optional bool inherited = 3 [default = true];
      case 3: {
        if (tag == 24) {
         parse_inherited:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &inherited_)));
          set_has_inherited();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_user_id;
        break;
      }

      // optional uint32 user_id = 4;
      case 4: {
        if (tag == 32) {
         parse_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_group;
        break;
      }

      // optional string group = 5;
      case 5: {
        if (tag == 42) {
         parse_group:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_group()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_grant;
        break;
      }

      // optional uint32 grant = 6;
      case 6: {
        if (tag == 48) {
         parse_grant:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &grant_)));
          set_has_grant();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_deny;
        break;
      }

      // optional uint32 deny = 7;
      case 7: {
        if (tag == 56) {
         parse_deny:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &deny_)));
          set_has_deny();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ACL.ChanACL)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ACL.ChanACL)
  return false;
#undef DO_
}

void ACL_ChanACL::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ACL.ChanACL)
  // optional bool apply_here = 1 [default = true];
  if (has_apply_here()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->apply_here(), output);
  }

  // optional bool apply_subs = 2 [default = true];
  if (has_apply_subs()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->apply_subs(), output);
  }

  // optional bool inherited = 3 [default = true];
  if (has_inherited()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->inherited(), output);
  }

  // optional uint32 user_id = 4;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->user_id(), output);
  }

  // optional string group = 5;
  if (has_group()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->group(), output);
  }

  // optional uint32 grant = 6;
  if (has_grant()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->grant(), output);
  }

  // optional uint32 deny = 7;
  if (has_deny()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->deny(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ACL.ChanACL)
}

int ACL_ChanACL::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 127) {
    // optional bool apply_here = 1 [default = true];
    if (has_apply_here()) {
      total_size += 1 + 1;
    }

    // optional bool apply_subs = 2 [default = true];
    if (has_apply_subs()) {
      total_size += 1 + 1;
    }

    // optional bool inherited = 3 [default = true];
    if (has_inherited()) {
      total_size += 1 + 1;
    }

    // optional uint32 user_id = 4;
    if (has_user_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->user_id());
    }

    // optional string group = 5;
    if (has_group()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->group());
    }

    // optional uint32 grant = 6;
    if (has_grant()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->grant());
    }

    // optional uint32 deny = 7;
    if (has_deny()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->deny());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ACL_ChanACL::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ACL_ChanACL*>(&from));
}

void ACL_ChanACL::MergeFrom(const ACL_ChanACL& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_apply_here()) {
      set_apply_here(from.apply_here());
    }
    if (from.has_apply_subs()) {
      set_apply_subs(from.apply_subs());
    }
    if (from.has_inherited()) {
      set_inherited(from.inherited());
    }
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_group()) {
      set_has_group();
      group_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.group_);
    }
    if (from.has_grant()) {
      set_grant(from.grant());
    }
    if (from.has_deny()) {
      set_deny(from.deny());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ACL_ChanACL::CopyFrom(const ACL_ChanACL& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ACL_ChanACL::IsInitialized() const {

  return true;
}

void ACL_ChanACL::Swap(ACL_ChanACL* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ACL_ChanACL::InternalSwap(ACL_ChanACL* other) {
  std::swap(apply_here_, other->apply_here_);
  std::swap(apply_subs_, other->apply_subs_);
  std::swap(inherited_, other->inherited_);
  std::swap(user_id_, other->user_id_);
  group_.Swap(&other->group_);
  std::swap(grant_, other->grant_);
  std::swap(deny_, other->deny_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ACL_ChanACL::GetTypeName() const {
  return "MumbleProto.ACL.ChanACL";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int ACL::kChannelIdFieldNumber;
const int ACL::kInheritAclsFieldNumber;
const int ACL::kGroupsFieldNumber;
const int ACL::kAclsFieldNumber;
const int ACL::kQueryFieldNumber;
#endif  // !_MSC_VER

ACL::ACL()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ACL)
}

void ACL::InitAsDefaultInstance() {
}

ACL::ACL(const ACL& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL)
}

void ACL::SharedCtor() {
  _cached_size_ = 0;
  channel_id_ = 0u;
  inherit_acls_ = true;
  query_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ACL::~ACL() {
  // @@protoc_insertion_point(destructor:MumbleProto.ACL)
  SharedDtor();
}

void ACL::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ACL::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ACL& ACL::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ACL* ACL::default_instance_ = NULL;

ACL* ACL::New(::google::protobuf::Arena* arena) const {
  ACL* n = new ACL;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ACL::Clear() {
  if (_has_bits_[0 / 32] & 19) {
    channel_id_ = 0u;
    inherit_acls_ = true;
    query_ = false;
  }
  groups_.Clear();
  acls_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ACL::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ACL)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 channel_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_inherit_acls;
        break;
      }

      // optional bool inherit_acls = 2 [default = true];
      case 2: {
        if (tag == 16) {
         parse_inherit_acls:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &inherit_acls_)));
          set_has_inherit_acls();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_groups;
        break;
      }

      // repeated .MumbleProto.ACL.ChanGroup groups = 3;
      case 3: {
        if (tag == 26) {
         parse_groups:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_groups()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_groups;
        if (input->ExpectTag(34)) goto parse_acls;
        break;
      }

      // repeated .MumbleProto.ACL.ChanACL acls = 4;
      case 4: {
        if (tag == 34) {
         parse_acls:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_acls()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_acls;
        if (input->ExpectTag(40)) goto parse_query;
        break;
      }

      // optional bool query = 5 [default = false];
      case 5: {
        if (tag == 40) {
         parse_query:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &query_)));
          set_has_query();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ACL)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ACL)
  return false;
#undef DO_
}

void ACL::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ACL)
  // required uint32 channel_id = 1;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->channel_id(), output);
  }

  // optional bool inherit_acls = 2 [default = true];
  if (has_inherit_acls()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->inherit_acls(), output);
  }

  // repeated .MumbleProto.ACL.ChanGroup groups = 3;
  for (unsigned int i = 0, n = this->groups_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->groups(i), output);
  }

  // repeated .MumbleProto.ACL.ChanACL acls = 4;
  for (unsigned int i = 0, n = this->acls_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->acls(i), output);
  }

  // optional bool query = 5 [default = false];
  if (has_query()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->query(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ACL)
}

int ACL::ByteSize() const {
  int total_size = 0;

  // required uint32 channel_id = 1;
  if (has_channel_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->channel_id());
  }
  if (_has_bits_[1 / 32] & 18) {
    // optional bool inherit_acls = 2 [default = true];
    if (has_inherit_acls()) {
      total_size += 1 + 1;
    }

    // optional bool query = 5 [default = false];
    if (has_query()) {
      total_size += 1 + 1;
    }

  }
  // repeated .MumbleProto.ACL.ChanGroup groups = 3;
  total_size += 1 * this->groups_size();
  for (int i = 0; i < this->groups_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->groups(i));
  }

  // repeated .MumbleProto.ACL.ChanACL acls = 4;
  total_size += 1 * this->acls_size();
  for (int i = 0; i < this->acls_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->acls(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ACL::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ACL*>(&from));
}

void ACL::MergeFrom(const ACL& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  groups_.MergeFrom(from.groups_);
  acls_.MergeFrom(from.acls_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_inherit_acls()) {
      set_inherit_acls(from.inherit_acls());
    }
    if (from.has_query()) {
      set_query(from.query());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ACL::CopyFrom(const ACL& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ACL::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->groups())) return false;
  return true;
}

void ACL::Swap(ACL* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ACL::InternalSwap(ACL* other) {
  std::swap(channel_id_, other->channel_id_);
  std::swap(inherit_acls_, other->inherit_acls_);
  groups_.UnsafeArenaSwap(&other->groups_);
  acls_.UnsafeArenaSwap(&other->acls_);
  std::swap(query_, other->query_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ACL::GetTypeName() const {
  return "MumbleProto.ACL";
}


// ===================================================================

#ifndef _MSC_VER
const int QueryUsers::kIdsFieldNumber;
const int QueryUsers::kNamesFieldNumber;
#endif  // !_MSC_VER

QueryUsers::QueryUsers()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.QueryUsers)
}

void QueryUsers::InitAsDefaultInstance() {
}

QueryUsers::QueryUsers(const QueryUsers& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.QueryUsers)
}

void QueryUsers::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryUsers::~QueryUsers() {
  // @@protoc_insertion_point(destructor:MumbleProto.QueryUsers)
  SharedDtor();
}

void QueryUsers::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void QueryUsers::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const QueryUsers& QueryUsers::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

QueryUsers* QueryUsers::default_instance_ = NULL;

QueryUsers* QueryUsers::New(::google::protobuf::Arena* arena) const {
  QueryUsers* n = new QueryUsers;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void QueryUsers::Clear() {
  ids_.Clear();
  names_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool QueryUsers::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.QueryUsers)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 ids = 1;
      case 1: {
        if (tag == 8) {
         parse_ids:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 8, input, this->mutable_ids())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_ids())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_ids;
        if (input->ExpectTag(18)) goto parse_names;
        break;
      }

      // repeated string names = 2;
      case 2: {
        if (tag == 18) {
         parse_names:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_names()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_names;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.QueryUsers)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.QueryUsers)
  return false;
#undef DO_
}

void QueryUsers::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.QueryUsers)
  // repeated uint32 ids = 1;
  for (int i = 0; i < this->ids_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      1, this->ids(i), output);
  }

  // repeated string names = 2;
  for (int i = 0; i < this->names_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->names(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.QueryUsers)
}

int QueryUsers::ByteSize() const {
  int total_size = 0;

  // repeated uint32 ids = 1;
  {
    int data_size = 0;
    for (int i = 0; i < this->ids_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->ids(i));
    }
    total_size += 1 * this->ids_size() + data_size;
  }

  // repeated string names = 2;
  total_size += 1 * this->names_size();
  for (int i = 0; i < this->names_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->names(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryUsers::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const QueryUsers*>(&from));
}

void QueryUsers::MergeFrom(const QueryUsers& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  ids_.MergeFrom(from.ids_);
  names_.MergeFrom(from.names_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void QueryUsers::CopyFrom(const QueryUsers& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryUsers::IsInitialized() const {

  return true;
}

void QueryUsers::Swap(QueryUsers* other) {
  if (other == this) return;
  InternalSwap(other);
}
void QueryUsers::InternalSwap(QueryUsers* other) {
  ids_.UnsafeArenaSwap(&other->ids_);
  names_.UnsafeArenaSwap(&other->names_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string QueryUsers::GetTypeName() const {
  return "MumbleProto.QueryUsers";
}


// ===================================================================

#ifndef _MSC_VER
const int CryptSetup::kKeyFieldNumber;
const int CryptSetup::kClientNonceFieldNumber;
const int CryptSetup::kServerNonceFieldNumber;
#endif  // !_MSC_VER

CryptSetup::CryptSetup()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.CryptSetup)
}

void CryptSetup::InitAsDefaultInstance() {
}

CryptSetup::CryptSetup(const CryptSetup& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.CryptSetup)
}

void CryptSetup::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  client_nonce_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  server_nonce_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CryptSetup::~CryptSetup() {
  // @@protoc_insertion_point(destructor:MumbleProto.CryptSetup)
  SharedDtor();
}

void CryptSetup::SharedDtor() {
  key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  client_nonce_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  server_nonce_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CryptSetup::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CryptSetup& CryptSetup::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

CryptSetup* CryptSetup::default_instance_ = NULL;

CryptSetup* CryptSetup::New(::google::protobuf::Arena* arena) const {
  CryptSetup* n = new CryptSetup;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CryptSetup::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_key()) {
      key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_client_nonce()) {
      client_nonce_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_server_nonce()) {
      server_nonce_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool CryptSetup::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.CryptSetup)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes key = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_key()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_client_nonce;
        break;
      }

      // optional bytes client_nonce = 2;
      case 2: {
        if (tag == 18) {
         parse_client_nonce:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_client_nonce()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_server_nonce;
        break;
      }

      // optional bytes server_nonce = 3;
      case 3: {
        if (tag == 26) {
         parse_server_nonce:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_server_nonce()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.CryptSetup)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.CryptSetup)
  return false;
#undef DO_
}

void CryptSetup::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.CryptSetup)
  // optional bytes key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->key(), output);
  }

  // optional bytes client_nonce = 2;
  if (has_client_nonce()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->client_nonce(), output);
  }

  // optional bytes server_nonce = 3;
  if (has_server_nonce()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->server_nonce(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.CryptSetup)
}

int CryptSetup::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 7) {
    // optional bytes key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->key());
    }

    // optional bytes client_nonce = 2;
    if (has_client_nonce()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->client_nonce());
    }

    // optional bytes server_nonce = 3;
    if (has_server_nonce()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->server_nonce());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CryptSetup::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CryptSetup*>(&from));
}

void CryptSetup::MergeFrom(const CryptSetup& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_key()) {
      set_has_key();
      key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
    }
    if (from.has_client_nonce()) {
      set_has_client_nonce();
      client_nonce_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.client_nonce_);
    }
    if (from.has_server_nonce()) {
      set_has_server_nonce();
      server_nonce_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.server_nonce_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void CryptSetup::CopyFrom(const CryptSetup& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CryptSetup::IsInitialized() const {

  return true;
}

void CryptSetup::Swap(CryptSetup* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CryptSetup::InternalSwap(CryptSetup* other) {
  key_.Swap(&other->key_);
  client_nonce_.Swap(&other->client_nonce_);
  server_nonce_.Swap(&other->server_nonce_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CryptSetup::GetTypeName() const {
  return "MumbleProto.CryptSetup";
}


// ===================================================================

bool ContextActionModify_Context_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ContextActionModify_Context ContextActionModify::Server;
const ContextActionModify_Context ContextActionModify::Channel;
const ContextActionModify_Context ContextActionModify::User;
const ContextActionModify_Context ContextActionModify::Context_MIN;
const ContextActionModify_Context ContextActionModify::Context_MAX;
const int ContextActionModify::Context_ARRAYSIZE;
#endif  // _MSC_VER
bool ContextActionModify_Operation_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ContextActionModify_Operation ContextActionModify::Add;
const ContextActionModify_Operation ContextActionModify::Remove;
const ContextActionModify_Operation ContextActionModify::Operation_MIN;
const ContextActionModify_Operation ContextActionModify::Operation_MAX;
const int ContextActionModify::Operation_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ContextActionModify::kActionFieldNumber;
const int ContextActionModify::kTextFieldNumber;
const int ContextActionModify::kContextFieldNumber;
const int ContextActionModify::kOperationFieldNumber;
#endif  // !_MSC_VER

ContextActionModify::ContextActionModify()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ContextActionModify)
}

void ContextActionModify::InitAsDefaultInstance() {
}

ContextActionModify::ContextActionModify(const ContextActionModify& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ContextActionModify)
}

void ContextActionModify::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  action_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  text_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  context_ = 0u;
  operation_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ContextActionModify::~ContextActionModify() {
  // @@protoc_insertion_point(destructor:MumbleProto.ContextActionModify)
  SharedDtor();
}

void ContextActionModify::SharedDtor() {
  action_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  text_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ContextActionModify::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ContextActionModify& ContextActionModify::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ContextActionModify* ContextActionModify::default_instance_ = NULL;

ContextActionModify* ContextActionModify::New(::google::protobuf::Arena* arena) const {
  ContextActionModify* n = new ContextActionModify;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ContextActionModify::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ContextActionModify*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(context_, operation_);
    if (has_action()) {
      action_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_text()) {
      text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ContextActionModify::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ContextActionModify)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string action = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_action()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_text;
        break;
      }

      // optional string text = 2;
      case 2: {
        if (tag == 18) {
         parse_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_context;
        break;
      }

      // optional uint32 context = 3;
      case 3: {
        if (tag == 24) {
         parse_context:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &context_)));
          set_has_context();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_operation;
        break;
      }

      // optional .MumbleProto.ContextActionModify.Operation operation = 4;
      case 4: {
        if (tag == 32) {
         parse_operation:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::MumbleProto::ContextActionModify_Operation_IsValid(value)) {
            set_operation(static_cast< ::MumbleProto::ContextActionModify_Operation >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ContextActionModify)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ContextActionModify)
  return false;
#undef DO_
}

void ContextActionModify::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ContextActionModify)
  // required string action = 1;
  if (has_action()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->action(), output);
  }

  // optional string text = 2;
  if (has_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->text(), output);
  }

  // optional uint32 context = 3;
  if (has_context()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->context(), output);
  }

  // optional .MumbleProto.ContextActionModify.Operation operation = 4;
  if (has_operation()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->operation(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ContextActionModify)
}

int ContextActionModify::ByteSize() const {
  int total_size = 0;

  // required string action = 1;
  if (has_action()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->action());
  }
  if (_has_bits_[1 / 32] & 14) {
    // optional string text = 2;
    if (has_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->text());
    }

    // optional uint32 context = 3;
    if (has_context()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->context());
    }

    // optional .MumbleProto.ContextActionModify.Operation operation = 4;
    if (has_operation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ContextActionModify::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ContextActionModify*>(&from));
}

void ContextActionModify::MergeFrom(const ContextActionModify& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_action()) {
      set_has_action();
      action_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.action_);
    }
    if (from.has_text()) {
      set_has_text();
      text_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.text_);
    }
    if (from.has_context()) {
      set_context(from.context());
    }
    if (from.has_operation()) {
      set_operation(from.operation());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ContextActionModify::CopyFrom(const ContextActionModify& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ContextActionModify::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ContextActionModify::Swap(ContextActionModify* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ContextActionModify::InternalSwap(ContextActionModify* other) {
  action_.Swap(&other->action_);
  text_.Swap(&other->text_);
  std::swap(context_, other->context_);
  std::swap(operation_, other->operation_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ContextActionModify::GetTypeName() const {
  return "MumbleProto.ContextActionModify";
}


// ===================================================================

#ifndef _MSC_VER
const int ContextAction::kSessionFieldNumber;
const int ContextAction::kChannelIdFieldNumber;
const int ContextAction::kActionFieldNumber;
#endif  // !_MSC_VER

ContextAction::ContextAction()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ContextAction)
}

void ContextAction::InitAsDefaultInstance() {
}

ContextAction::ContextAction(const ContextAction& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ContextAction)
}

void ContextAction::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  session_ = 0u;
  channel_id_ = 0u;
  action_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ContextAction::~ContextAction() {
  // @@protoc_insertion_point(destructor:MumbleProto.ContextAction)
  SharedDtor();
}

void ContextAction::SharedDtor() {
  action_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ContextAction::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ContextAction& ContextAction::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ContextAction* ContextAction::default_instance_ = NULL;

ContextAction* ContextAction::New(::google::protobuf::Arena* arena) const {
  ContextAction* n = new ContextAction;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ContextAction::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ContextAction*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(session_, channel_id_);
    if (has_action()) {
      action_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ContextAction::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ContextAction)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 session = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_channel_id;
        break;
      }

      // optional uint32 channel_id = 2;
      case 2: {
        if (tag == 16) {
         parse_channel_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_action;
        break;
      }

      // required string action = 3;
      case 3: {
        if (tag == 26) {
         parse_action:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_action()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ContextAction)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ContextAction)
  return false;
#undef DO_
}

void ContextAction::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ContextAction)
  // optional uint32 session = 1;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->session(), output);
  }

  // optional uint32 channel_id = 2;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->channel_id(), output);
  }

  // required string action = 3;
  if (has_action()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->action(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ContextAction)
}

int ContextAction::ByteSize() const {
  int total_size = 0;

  // required string action = 3;
  if (has_action()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->action());
  }
  if (_has_bits_[0 / 32] & 3) {
    // optional uint32 session = 1;
    if (has_session()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->session());
    }

    // optional uint32 channel_id = 2;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ContextAction::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ContextAction*>(&from));
}

void ContextAction::MergeFrom(const ContextAction& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_action()) {
      set_has_action();
      action_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.action_);
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ContextAction::CopyFrom(const ContextAction& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ContextAction::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;

  return true;
}

void ContextAction::Swap(ContextAction* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ContextAction::InternalSwap(ContextAction* other) {
  std::swap(session_, other->session_);
  std::swap(channel_id_, other->channel_id_);
  action_.Swap(&other->action_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ContextAction::GetTypeName() const {
  return "MumbleProto.ContextAction";
}


// ===================================================================

#ifndef _MSC_VER
const int UserList_User::kUserIdFieldNumber;
const int UserList_User::kNameFieldNumber;
const int UserList_User::kLastSeenFieldNumber;
const int UserList_User::kLastChannelFieldNumber;
#endif  // !_MSC_VER

UserList_User::UserList_User()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserList.User)
}

void UserList_User::InitAsDefaultInstance() {
}

UserList_User::UserList_User(const UserList_User& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserList.User)
}

void UserList_User::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  last_seen_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  last_channel_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserList_User::~UserList_User() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserList.User)
  SharedDtor();
}

void UserList_User::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  last_seen_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UserList_User::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserList_User& UserList_User::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserList_User* UserList_User::default_instance_ = NULL;

UserList_User* UserList_User::New(::google::protobuf::Arena* arena) const {
  UserList_User* n = new UserList_User;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserList_User::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<UserList_User*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(user_id_, last_channel_);
    if (has_name()) {
      name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    if (has_last_seen()) {
      last_seen_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserList_User::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserList.User)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (tag == 18) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_last_seen;
        break;
      }

      // optional string last_seen = 3;
      case 3: {
        if (tag == 26) {
         parse_last_seen:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_last_seen()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_last_channel;
        break;
      }

      // optional uint32 last_channel = 4;
      case 4: {
        if (tag == 32) {
         parse_last_channel:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &last_channel_)));
          set_has_last_channel();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserList.User)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserList.User)
  return false;
#undef DO_
}

void UserList_User::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserList.User)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->name(), output);
  }

  // optional string last_seen = 3;
  if (has_last_seen()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->last_seen(), output);
  }

  // optional uint32 last_channel = 4;
  if (has_last_channel()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->last_channel(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserList.User)
}

int UserList_User::ByteSize() const {
  int total_size = 0;

  // required uint32 user_id = 1;
  if (has_user_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->user_id());
  }
  if (_has_bits_[1 / 32] & 14) {
    // optional string name = 2;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string last_seen = 3;
    if (has_last_seen()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->last_seen());
    }

    // optional uint32 last_channel = 4;
    if (has_last_channel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->last_channel());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserList_User::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserList_User*>(&from));
}

void UserList_User::MergeFrom(const UserList_User& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (from.has_last_seen()) {
      set_has_last_seen();
      last_seen_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.last_seen_);
    }
    if (from.has_last_channel()) {
      set_last_channel(from.last_channel());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserList_User::CopyFrom(const UserList_User& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserList_User::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void UserList_User::Swap(UserList_User* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserList_User::InternalSwap(UserList_User* other) {
  std::swap(user_id_, other->user_id_);
  name_.Swap(&other->name_);
  last_seen_.Swap(&other->last_seen_);
  std::swap(last_channel_, other->last_channel_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserList_User::GetTypeName() const {
  return "MumbleProto.UserList.User";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int UserList::kUsersFieldNumber;
#endif  // !_MSC_VER

UserList::UserList()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserList)
}

void UserList::InitAsDefaultInstance() {
}

UserList::UserList(const UserList& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserList)
}

void UserList::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserList::~UserList() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserList)
  SharedDtor();
}

void UserList::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UserList::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserList& UserList::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserList* UserList::default_instance_ = NULL;

UserList* UserList::New(::google::protobuf::Arena* arena) const {
  UserList* n = new UserList;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserList::Clear() {
  users_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserList::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserList)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .MumbleProto.UserList.User users = 1;
      case 1: {
        if (tag == 10) {
         parse_users:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_users()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_users;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserList)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserList)
  return false;
#undef DO_
}

void UserList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserList)
  // repeated .MumbleProto.UserList.User users = 1;
  for (unsigned int i = 0, n = this->users_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->users(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserList)
}

int UserList::ByteSize() const {
  int total_size = 0;

  // repeated .MumbleProto.UserList.User users = 1;
  total_size += 1 * this->users_size();
  for (int i = 0; i < this->users_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->users(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserList::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserList*>(&from));
}

void UserList::MergeFrom(const UserList& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  users_.MergeFrom(from.users_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserList::CopyFrom(const UserList& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserList::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->users())) return false;
  return true;
}

void UserList::Swap(UserList* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserList::InternalSwap(UserList* other) {
  users_.UnsafeArenaSwap(&other->users_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserList::GetTypeName() const {
  return "MumbleProto.UserList";
}


// ===================================================================

#ifndef _MSC_VER
const int VoiceTarget_Target::kSessionFieldNumber;
const int VoiceTarget_Target::kChannelIdFieldNumber;
const int VoiceTarget_Target::kGroupFieldNumber;
const int VoiceTarget_Target::kLinksFieldNumber;
const int VoiceTarget_Target::kChildrenFieldNumber;
#endif  // !_MSC_VER

VoiceTarget_Target::VoiceTarget_Target()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.VoiceTarget.Target)
}

void VoiceTarget_Target::InitAsDefaultInstance() {
}

VoiceTarget_Target::VoiceTarget_Target(const VoiceTarget_Target& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.VoiceTarget.Target)
}

void VoiceTarget_Target::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  channel_id_ = 0u;
  group_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  links_ = false;
  children_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

VoiceTarget_Target::~VoiceTarget_Target() {
  // @@protoc_insertion_point(destructor:MumbleProto.VoiceTarget.Target)
  SharedDtor();
}

void VoiceTarget_Target::SharedDtor() {
  group_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void VoiceTarget_Target::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const VoiceTarget_Target& VoiceTarget_Target::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

VoiceTarget_Target* VoiceTarget_Target::default_instance_ = NULL;

VoiceTarget_Target* VoiceTarget_Target::New(::google::protobuf::Arena* arena) const {
  VoiceTarget_Target* n = new VoiceTarget_Target;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void VoiceTarget_Target::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<VoiceTarget_Target*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 30) {
    ZR_(channel_id_, children_);
    if (has_group()) {
      group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  session_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool VoiceTarget_Target::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.VoiceTarget.Target)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 session = 1;
      case 1: {
        if (tag == 8) {
         parse_session:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 8, input, this->mutable_session())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_session())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_session;
        if (input->ExpectTag(16)) goto parse_channel_id;
        break;
      }

      // optional uint32 channel_id = 2;
      case 2: {
        if (tag == 16) {
         parse_channel_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_group;
        break;
      }

      // optional string group = 3;
      case 3: {
        if (tag == 26) {
         parse_group:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_group()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_links;
        break;
      }

      // optional bool links = 4 [default = false];
      case 4: {
        if (tag == 32) {
         parse_links:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &links_)));
          set_has_links();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_children;
        break;
      }

      // optional bool children = 5 [default = false];
      case 5: {
        if (tag == 40) {
         parse_children:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &children_)));
          set_has_children();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.VoiceTarget.Target)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.VoiceTarget.Target)
  return false;
#undef DO_
}

void VoiceTarget_Target::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.VoiceTarget.Target)
  // repeated uint32 session = 1;
  for (int i = 0; i < this->session_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      1, this->session(i), output);
  }

  // optional uint32 channel_id = 2;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->channel_id(), output);
  }

  // optional string group = 3;
  if (has_group()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->group(), output);
  }

  // optional bool links = 4 [default = false];
  if (has_links()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->links(), output);
  }

  // optional bool children = 5 [default = false];
  if (has_children()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->children(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.VoiceTarget.Target)
}

int VoiceTarget_Target::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[1 / 32] & 30) {
    // optional uint32 channel_id = 2;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

    // optional string group = 3;
    if (has_group()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->group());
    }

    // optional bool links = 4 [default = false];
    if (has_links()) {
      total_size += 1 + 1;
    }

    // optional bool children = 5 [default = false];
    if (has_children()) {
      total_size += 1 + 1;
    }

  }
  // repeated uint32 session = 1;
  {
    int data_size = 0;
    for (int i = 0; i < this->session_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->session(i));
    }
    total_size += 1 * this->session_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void VoiceTarget_Target::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const VoiceTarget_Target*>(&from));
}

void VoiceTarget_Target::MergeFrom(const VoiceTarget_Target& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  session_.MergeFrom(from.session_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_group()) {
      set_has_group();
      group_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.group_);
    }
    if (from.has_links()) {
      set_links(from.links());
    }
    if (from.has_children()) {
      set_children(from.children());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void VoiceTarget_Target::CopyFrom(const VoiceTarget_Target& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VoiceTarget_Target::IsInitialized() const {

  return true;
}

void VoiceTarget_Target::Swap(VoiceTarget_Target* other) {
  if (other == this) return;
  InternalSwap(other);
}
void VoiceTarget_Target::InternalSwap(VoiceTarget_Target* other) {
  session_.UnsafeArenaSwap(&other->session_);
  std::swap(channel_id_, other->channel_id_);
  group_.Swap(&other->group_);
  std::swap(links_, other->links_);
  std::swap(children_, other->children_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string VoiceTarget_Target::GetTypeName() const {
  return "MumbleProto.VoiceTarget.Target";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int VoiceTarget::kIdFieldNumber;
const int VoiceTarget::kTargetsFieldNumber;
#endif  // !_MSC_VER

VoiceTarget::VoiceTarget()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.VoiceTarget)
}

void VoiceTarget::InitAsDefaultInstance() {
}

VoiceTarget::VoiceTarget(const VoiceTarget& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.VoiceTarget)
}

void VoiceTarget::SharedCtor() {
  _cached_size_ = 0;
  id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

VoiceTarget::~VoiceTarget() {
  // @@protoc_insertion_point(destructor:MumbleProto.VoiceTarget)
  SharedDtor();
}

void VoiceTarget::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void VoiceTarget::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const VoiceTarget& VoiceTarget::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

VoiceTarget* VoiceTarget::default_instance_ = NULL;

VoiceTarget* VoiceTarget::New(::google::protobuf::Arena* arena) const {
  VoiceTarget* n = new VoiceTarget;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void VoiceTarget::Clear() {
  id_ = 0u;
  targets_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool VoiceTarget::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.VoiceTarget)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &id_)));
          set_has_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_targets;
        break;
      }

      // repeated .MumbleProto.VoiceTarget.Target targets = 2;
      case 2: {
        if (tag == 18) {
         parse_targets:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_targets()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_targets;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.VoiceTarget)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.VoiceTarget)
  return false;
#undef DO_
}

void VoiceTarget::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.VoiceTarget)
  // optional uint32 id = 1;
  if (has_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
  }

  // repeated .MumbleProto.VoiceTarget.Target targets = 2;
  for (unsigned int i = 0, n = this->targets_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->targets(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.VoiceTarget)
}

int VoiceTarget::ByteSize() const {
  int total_size = 0;

  // optional uint32 id = 1;
  if (has_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->id());
  }

  // repeated .MumbleProto.VoiceTarget.Target targets = 2;
  total_size += 1 * this->targets_size();
  for (int i = 0; i < this->targets_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->targets(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void VoiceTarget::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const VoiceTarget*>(&from));
}

void VoiceTarget::MergeFrom(const VoiceTarget& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  targets_.MergeFrom(from.targets_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_id()) {
      set_id(from.id());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void VoiceTarget::CopyFrom(const VoiceTarget& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VoiceTarget::IsInitialized() const {

  return true;
}

void VoiceTarget::Swap(VoiceTarget* other) {
  if (other == this) return;
  InternalSwap(other);
}
void VoiceTarget::InternalSwap(VoiceTarget* other) {
  std::swap(id_, other->id_);
  targets_.UnsafeArenaSwap(&other->targets_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string VoiceTarget::GetTypeName() const {
  return "MumbleProto.VoiceTarget";
}


// ===================================================================

#ifndef _MSC_VER
const int PermissionQuery::kChannelIdFieldNumber;
const int PermissionQuery::kPermissionsFieldNumber;
const int PermissionQuery::kFlushFieldNumber;
#endif  // !_MSC_VER

PermissionQuery::PermissionQuery()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.PermissionQuery)
}

void PermissionQuery::InitAsDefaultInstance() {
}

PermissionQuery::PermissionQuery(const PermissionQuery& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.PermissionQuery)
}

void PermissionQuery::SharedCtor() {
  _cached_size_ = 0;
  channel_id_ = 0u;
  permissions_ = 0u;
  flush_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PermissionQuery::~PermissionQuery() {
  // @@protoc_insertion_point(destructor:MumbleProto.PermissionQuery)
  SharedDtor();
}

void PermissionQuery::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PermissionQuery::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PermissionQuery& PermissionQuery::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

PermissionQuery* PermissionQuery::default_instance_ = NULL;

PermissionQuery* PermissionQuery::New(::google::protobuf::Arena* arena) const {
  PermissionQuery* n = new PermissionQuery;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PermissionQuery::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PermissionQuery*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(channel_id_, flush_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PermissionQuery::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.PermissionQuery)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 channel_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channel_id_)));
          set_has_channel_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_permissions;
        break;
      }

      // optional uint32 permissions = 2;
      case 2: {
        if (tag == 16) {
         parse_permissions:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &permissions_)));
          set_has_permissions();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_flush;
        break;
      }

      // optional bool flush = 3 [default = false];
      case 3: {
        if (tag == 24) {
         parse_flush:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &flush_)));
          set_has_flush();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.PermissionQuery)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.PermissionQuery)
  return false;
#undef DO_
}

void PermissionQuery::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.PermissionQuery)
  // optional uint32 channel_id = 1;
  if (has_channel_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->channel_id(), output);
  }

  // optional uint32 permissions = 2;
  if (has_permissions()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->permissions(), output);
  }

  // optional bool flush = 3 [default = false];
  if (has_flush()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->flush(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.PermissionQuery)
}

int PermissionQuery::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 7) {
    // optional uint32 channel_id = 1;
    if (has_channel_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channel_id());
    }

    // optional uint32 permissions = 2;
    if (has_permissions()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->permissions());
    }

    // optional bool flush = 3 [default = false];
    if (has_flush()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PermissionQuery::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PermissionQuery*>(&from));
}

void PermissionQuery::MergeFrom(const PermissionQuery& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel_id()) {
      set_channel_id(from.channel_id());
    }
    if (from.has_permissions()) {
      set_permissions(from.permissions());
    }
    if (from.has_flush()) {
      set_flush(from.flush());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PermissionQuery::CopyFrom(const PermissionQuery& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PermissionQuery::IsInitialized() const {

  return true;
}

void PermissionQuery::Swap(PermissionQuery* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PermissionQuery::InternalSwap(PermissionQuery* other) {
  std::swap(channel_id_, other->channel_id_);
  std::swap(permissions_, other->permissions_);
  std::swap(flush_, other->flush_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PermissionQuery::GetTypeName() const {
  return "MumbleProto.PermissionQuery";
}


// ===================================================================

#ifndef _MSC_VER
const int CodecVersion::kAlphaFieldNumber;
const int CodecVersion::kBetaFieldNumber;
const int CodecVersion::kPreferAlphaFieldNumber;
const int CodecVersion::kOpusFieldNumber;
#endif  // !_MSC_VER

CodecVersion::CodecVersion()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.CodecVersion)
}

void CodecVersion::InitAsDefaultInstance() {
}

CodecVersion::CodecVersion(const CodecVersion& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.CodecVersion)
}

void CodecVersion::SharedCtor() {
  _cached_size_ = 0;
  alpha_ = 0;
  beta_ = 0;
  prefer_alpha_ = true;
  opus_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CodecVersion::~CodecVersion() {
  // @@protoc_insertion_point(destructor:MumbleProto.CodecVersion)
  SharedDtor();
}

void CodecVersion::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CodecVersion::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CodecVersion& CodecVersion::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

CodecVersion* CodecVersion::default_instance_ = NULL;

CodecVersion* CodecVersion::New(::google::protobuf::Arena* arena) const {
  CodecVersion* n = new CodecVersion;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CodecVersion::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<CodecVersion*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(alpha_, beta_);
    prefer_alpha_ = true;
    opus_ = false;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool CodecVersion::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.CodecVersion)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 alpha = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &alpha_)));
          set_has_alpha();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_beta;
        break;
      }

      // required int32 beta = 2;
      case 2: {
        if (tag == 16) {
         parse_beta:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &beta_)));
          set_has_beta();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_prefer_alpha;
        break;
      }

      // required bool prefer_alpha = 3 [default = true];
      case 3: {
        if (tag == 24) {
         parse_prefer_alpha:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &prefer_alpha_)));
          set_has_prefer_alpha();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_opus;
        break;
      }

      // optional bool opus = 4 [default = false];
      case 4: {
        if (tag == 32) {
         parse_opus:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &opus_)));
          set_has_opus();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.CodecVersion)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.CodecVersion)
  return false;
#undef DO_
}

void CodecVersion::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.CodecVersion)
  // required int32 alpha = 1;
  if (has_alpha()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->alpha(), output);
  }

  // required int32 beta = 2;
  if (has_beta()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->beta(), output);
  }

  // required bool prefer_alpha = 3 [default = true];
  if (has_prefer_alpha()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->prefer_alpha(), output);
  }

  // optional bool opus = 4 [default = false];
  if (has_opus()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->opus(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.CodecVersion)
}

int CodecVersion::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_alpha()) {
    // required int32 alpha = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->alpha());
  }

  if (has_beta()) {
    // required int32 beta = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->beta());
  }

  if (has_prefer_alpha()) {
    // required bool prefer_alpha = 3 [default = true];
    total_size += 1 + 1;
  }

  return total_size;
}
int CodecVersion::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required int32 alpha = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->alpha());

    // required int32 beta = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->beta());

    // required bool prefer_alpha = 3 [default = true];
    total_size += 1 + 1;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // optional bool opus = 4 [default = false];
  if (has_opus()) {
    total_size += 1 + 1;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CodecVersion::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CodecVersion*>(&from));
}

void CodecVersion::MergeFrom(const CodecVersion& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_alpha()) {
      set_alpha(from.alpha());
    }
    if (from.has_beta()) {
      set_beta(from.beta());
    }
    if (from.has_prefer_alpha()) {
      set_prefer_alpha(from.prefer_alpha());
    }
    if (from.has_opus()) {
      set_opus(from.opus());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void CodecVersion::CopyFrom(const CodecVersion& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CodecVersion::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void CodecVersion::Swap(CodecVersion* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CodecVersion::InternalSwap(CodecVersion* other) {
  std::swap(alpha_, other->alpha_);
  std::swap(beta_, other->beta_);
  std::swap(prefer_alpha_, other->prefer_alpha_);
  std::swap(opus_, other->opus_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CodecVersion::GetTypeName() const {
  return "MumbleProto.CodecVersion";
}


// ===================================================================

#ifndef _MSC_VER
const int UserStats_Stats::kGoodFieldNumber;
const int UserStats_Stats::kLateFieldNumber;
const int UserStats_Stats::kLostFieldNumber;
const int UserStats_Stats::kResyncFieldNumber;
#endif  // !_MSC_VER

UserStats_Stats::UserStats_Stats()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserStats.Stats)
}

void UserStats_Stats::InitAsDefaultInstance() {
}

UserStats_Stats::UserStats_Stats(const UserStats_Stats& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserStats.Stats)
}

void UserStats_Stats::SharedCtor() {
  _cached_size_ = 0;
  good_ = 0u;
  late_ = 0u;
  lost_ = 0u;
  resync_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserStats_Stats::~UserStats_Stats() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserStats.Stats)
  SharedDtor();
}

void UserStats_Stats::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UserStats_Stats::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserStats_Stats& UserStats_Stats::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserStats_Stats* UserStats_Stats::default_instance_ = NULL;

UserStats_Stats* UserStats_Stats::New(::google::protobuf::Arena* arena) const {
  UserStats_Stats* n = new UserStats_Stats;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserStats_Stats::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<UserStats_Stats*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(good_, resync_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserStats_Stats::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserStats.Stats)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 good = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &good_)));
          set_has_good();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_late;
        break;
      }

      // optional uint32 late = 2;
      case 2: {
        if (tag == 16) {
         parse_late:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &late_)));
          set_has_late();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_lost;
        break;
      }

      // optional uint32 lost = 3;
      case 3: {
        if (tag == 24) {
         parse_lost:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &lost_)));
          set_has_lost();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_resync;
        break;
      }

      // optional uint32 resync = 4;
      case 4: {
        if (tag == 32) {
         parse_resync:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &resync_)));
          set_has_resync();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserStats.Stats)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserStats.Stats)
  return false;
#undef DO_
}

void UserStats_Stats::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserStats.Stats)
  // optional uint32 good = 1;
  if (has_good()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->good(), output);
  }

  // optional uint32 late = 2;
  if (has_late()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->late(), output);
  }

  // optional uint32 lost = 3;
  if (has_lost()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->lost(), output);
  }

  // optional uint32 resync = 4;
  if (has_resync()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->resync(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserStats.Stats)
}

int UserStats_Stats::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 15) {
    // optional uint32 good = 1;
    if (has_good()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->good());
    }

    // optional uint32 late = 2;
    if (has_late()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->late());
    }

    // optional uint32 lost = 3;
    if (has_lost()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->lost());
    }

    // optional uint32 resync = 4;
    if (has_resync()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->resync());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserStats_Stats::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserStats_Stats*>(&from));
}

void UserStats_Stats::MergeFrom(const UserStats_Stats& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_good()) {
      set_good(from.good());
    }
    if (from.has_late()) {
      set_late(from.late());
    }
    if (from.has_lost()) {
      set_lost(from.lost());
    }
    if (from.has_resync()) {
      set_resync(from.resync());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserStats_Stats::CopyFrom(const UserStats_Stats& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserStats_Stats::IsInitialized() const {

  return true;
}

void UserStats_Stats::Swap(UserStats_Stats* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserStats_Stats::InternalSwap(UserStats_Stats* other) {
  std::swap(good_, other->good_);
  std::swap(late_, other->late_);
  std::swap(lost_, other->lost_);
  std::swap(resync_, other->resync_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserStats_Stats::GetTypeName() const {
  return "MumbleProto.UserStats.Stats";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int UserStats::kSessionFieldNumber;
const int UserStats::kStatsOnlyFieldNumber;
const int UserStats::kCertificatesFieldNumber;
const int UserStats::kFromClientFieldNumber;
const int UserStats::kFromServerFieldNumber;
const int UserStats::kUdpPacketsFieldNumber;
const int UserStats::kTcpPacketsFieldNumber;
const int UserStats::kUdpPingAvgFieldNumber;
const int UserStats::kUdpPingVarFieldNumber;
const int UserStats::kTcpPingAvgFieldNumber;
const int UserStats::kTcpPingVarFieldNumber;
const int UserStats::kVersionFieldNumber;
const int UserStats::kCeltVersionsFieldNumber;
const int UserStats::kAddressFieldNumber;
const int UserStats::kBandwidthFieldNumber;
const int UserStats::kOnlinesecsFieldNumber;
const int UserStats::kIdlesecsFieldNumber;
const int UserStats::kStrongCertificateFieldNumber;
const int UserStats::kOpusFieldNumber;
#endif  // !_MSC_VER

UserStats::UserStats()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.UserStats)
}

void UserStats::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  from_client_ = const_cast< ::MumbleProto::UserStats_Stats*>(
      ::MumbleProto::UserStats_Stats::internal_default_instance());
#else
  from_client_ = const_cast< ::MumbleProto::UserStats_Stats*>(&::MumbleProto::UserStats_Stats::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  from_server_ = const_cast< ::MumbleProto::UserStats_Stats*>(
      ::MumbleProto::UserStats_Stats::internal_default_instance());
#else
  from_server_ = const_cast< ::MumbleProto::UserStats_Stats*>(&::MumbleProto::UserStats_Stats::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  version_ = const_cast< ::MumbleProto::Version*>(
      ::MumbleProto::Version::internal_default_instance());
#else
  version_ = const_cast< ::MumbleProto::Version*>(&::MumbleProto::Version::default_instance());
#endif
}

UserStats::UserStats(const UserStats& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.UserStats)
}

void UserStats::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  session_ = 0u;
  stats_only_ = false;
  from_client_ = NULL;
  from_server_ = NULL;
  udp_packets_ = 0u;
  tcp_packets_ = 0u;
  udp_ping_avg_ = 0;
  udp_ping_var_ = 0;
  tcp_ping_avg_ = 0;
  tcp_ping_var_ = 0;
  version_ = NULL;
  address_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  bandwidth_ = 0u;
  onlinesecs_ = 0u;
  idlesecs_ = 0u;
  strong_certificate_ = false;
  opus_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserStats::~UserStats() {
  // @@protoc_insertion_point(destructor:MumbleProto.UserStats)
  SharedDtor();
}

void UserStats::SharedDtor() {
  address_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete from_client_;
    delete from_server_;
    delete version_;
  }
}

void UserStats::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UserStats& UserStats::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

UserStats* UserStats::default_instance_ = NULL;

UserStats* UserStats::New(::google::protobuf::Arena* arena) const {
  UserStats* n = new UserStats;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void UserStats::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<UserStats*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 251) {
    ZR_(session_, udp_packets_);
    ZR_(tcp_packets_, udp_ping_avg_);
    stats_only_ = false;
    if (has_from_client()) {
      if (from_client_ != NULL) from_client_->::MumbleProto::UserStats_Stats::Clear();
    }
    if (has_from_server()) {
      if (from_server_ != NULL) from_server_->::MumbleProto::UserStats_Stats::Clear();
    }
  }
  if (_has_bits_[8 / 32] & 61184) {
    ZR_(udp_ping_var_, tcp_ping_avg_);
    ZR_(bandwidth_, onlinesecs_);
    tcp_ping_var_ = 0;
    if (has_version()) {
      if (version_ != NULL) version_->::MumbleProto::Version::Clear();
    }
    if (has_address()) {
      address_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  if (_has_bits_[16 / 32] & 458752) {
    ZR_(strong_certificate_, opus_);
    idlesecs_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  certificates_.Clear();
  celt_versions_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UserStats::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.UserStats)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 session = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &session_)));
          set_has_session();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_stats_only;
        break;
      }

      // optional bool stats_only = 2 [default = false];
      case 2: {
        if (tag == 16) {
         parse_stats_only:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &stats_only_)));
          set_has_stats_only();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_certificates;
        break;
      }

      // repeated bytes certificates = 3;
      case 3: {
        if (tag == 26) {
         parse_certificates:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_certificates()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_certificates;
        if (input->ExpectTag(34)) goto parse_from_client;
        break;
      }

      // optional .MumbleProto.UserStats.Stats from_client = 4;
      case 4: {
        if (tag == 34) {
         parse_from_client:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_from_client()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_from_server;
        break;
      }

      // optional .MumbleProto.UserStats.Stats from_server = 5;
      case 5: {
        if (tag == 42) {
         parse_from_server:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_from_server()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_udp_packets;
        break;
      }

      // optional uint32 udp_packets = 6;
      case 6: {
        if (tag == 48) {
         parse_udp_packets:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &udp_packets_)));
          set_has_udp_packets();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_tcp_packets;
        break;
      }

      // optional uint32 tcp_packets = 7;
      case 7: {
        if (tag == 56) {
         parse_tcp_packets:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &tcp_packets_)));
          set_has_tcp_packets();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_udp_ping_avg;
        break;
      }

      // optional float udp_ping_avg = 8;
      case 8: {
        if (tag == 69) {
         parse_udp_ping_avg:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &udp_ping_avg_)));
          set_has_udp_ping_avg();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(77)) goto parse_udp_ping_var;
        break;
      }

      // optional float udp_ping_var = 9;
      case 9: {
        if (tag == 77) {
         parse_udp_ping_var:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &udp_ping_var_)));
          set_has_udp_ping_var();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(85)) goto parse_tcp_ping_avg;
        break;
      }

      // optional float tcp_ping_avg = 10;
      case 10: {
        if (tag == 85) {
         parse_tcp_ping_avg:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tcp_ping_avg_)));
          set_has_tcp_ping_avg();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(93)) goto parse_tcp_ping_var;
        break;
      }

      // optional float tcp_ping_var = 11;
      case 11: {
        if (tag == 93) {
         parse_tcp_ping_var:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tcp_ping_var_)));
          set_has_tcp_ping_var();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(98)) goto parse_version;
        break;
      }

      // optional .MumbleProto.Version version = 12;
      case 12: {
        if (tag == 98) {
         parse_version:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_version()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(104)) goto parse_celt_versions;
        break;
      }

      // repeated int32 celt_versions = 13;
      case 13: {
        if (tag == 104) {
         parse_celt_versions:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 104, input, this->mutable_celt_versions())));
        } else if (tag == 106) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_celt_versions())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(104)) goto parse_celt_versions;
        if (input->ExpectTag(114)) goto parse_address;
        break;
      }

      // optional bytes address = 14;
      case 14: {
        if (tag == 114) {
         parse_address:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_address()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(120)) goto parse_bandwidth;
        break;
      }

      // optional uint32 bandwidth = 15;
      case 15: {
        if (tag == 120) {
         parse_bandwidth:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &bandwidth_)));
          set_has_bandwidth();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(128)) goto parse_onlinesecs;
        break;
      }

      // optional uint32 onlinesecs = 16;
      case 16: {
        if (tag == 128) {
         parse_onlinesecs:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &onlinesecs_)));
          set_has_onlinesecs();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(136)) goto parse_idlesecs;
        break;
      }

      // optional uint32 idlesecs = 17;
      case 17: {
        if (tag == 136) {
         parse_idlesecs:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &idlesecs_)));
          set_has_idlesecs();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(144)) goto parse_strong_certificate;
        break;
      }

      // optional bool strong_certificate = 18 [default = false];
      case 18: {
        if (tag == 144) {
         parse_strong_certificate:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &strong_certificate_)));
          set_has_strong_certificate();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(152)) goto parse_opus;
        break;
      }

      // optional bool opus = 19 [default = false];
      case 19: {
        if (tag == 152) {
         parse_opus:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &opus_)));
          set_has_opus();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.UserStats)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.UserStats)
  return false;
#undef DO_
}

void UserStats::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.UserStats)
  // optional uint32 session = 1;
  if (has_session()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->session(), output);
  }

  // optional bool stats_only = 2 [default = false];
  if (has_stats_only()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->stats_only(), output);
  }

  // repeated bytes certificates = 3;
  for (int i = 0; i < this->certificates_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      3, this->certificates(i), output);
  }

  // optional .MumbleProto.UserStats.Stats from_client = 4;
  if (has_from_client()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->from_client_, output);
  }

  // optional .MumbleProto.UserStats.Stats from_server = 5;
  if (has_from_server()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, *this->from_server_, output);
  }

  // optional uint32 udp_packets = 6;
  if (has_udp_packets()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->udp_packets(), output);
  }

  // optional uint32 tcp_packets = 7;
  if (has_tcp_packets()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->tcp_packets(), output);
  }

  // optional float udp_ping_avg = 8;
  if (has_udp_ping_avg()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->udp_ping_avg(), output);
  }

  // optional float udp_ping_var = 9;
  if (has_udp_ping_var()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->udp_ping_var(), output);
  }

  // optional float tcp_ping_avg = 10;
  if (has_tcp_ping_avg()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->tcp_ping_avg(), output);
  }

  // optional float tcp_ping_var = 11;
  if (has_tcp_ping_var()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->tcp_ping_var(), output);
  }

  // optional .MumbleProto.Version version = 12;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      12, *this->version_, output);
  }

  // repeated int32 celt_versions = 13;
  for (int i = 0; i < this->celt_versions_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      13, this->celt_versions(i), output);
  }

  // optional bytes address = 14;
  if (has_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      14, this->address(), output);
  }

  // optional uint32 bandwidth = 15;
  if (has_bandwidth()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(15, this->bandwidth(), output);
  }

  // optional uint32 onlinesecs = 16;
  if (has_onlinesecs()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(16, this->onlinesecs(), output);
  }

  // optional uint32 idlesecs = 17;
  if (has_idlesecs()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(17, this->idlesecs(), output);
  }

  // optional bool strong_certificate = 18 [default = false];
  if (has_strong_certificate()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->strong_certificate(), output);
  }

  // optional bool opus = 19 [default = false];
  if (has_opus()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->opus(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.UserStats)
}

int UserStats::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 251) {
    // optional uint32 session = 1;
    if (has_session()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->session());
    }

    // optional bool stats_only = 2 [default = false];
    if (has_stats_only()) {
      total_size += 1 + 1;
    }

    // optional .MumbleProto.UserStats.Stats from_client = 4;
    if (has_from_client()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->from_client_);
    }

    // optional .MumbleProto.UserStats.Stats from_server = 5;
    if (has_from_server()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->from_server_);
    }

    // optional uint32 udp_packets = 6;
    if (has_udp_packets()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->udp_packets());
    }

    // optional uint32 tcp_packets = 7;
    if (has_tcp_packets()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->tcp_packets());
    }

    // optional float udp_ping_avg = 8;
    if (has_udp_ping_avg()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & 61184) {
    // optional float udp_ping_var = 9;
    if (has_udp_ping_var()) {
      total_size += 1 + 4;
    }

    // optional float tcp_ping_avg = 10;
    if (has_tcp_ping_avg()) {
      total_size += 1 + 4;
    }

    // optional float tcp_ping_var = 11;
    if (has_tcp_ping_var()) {
      total_size += 1 + 4;
    }

    // optional .MumbleProto.Version version = 12;
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->version_);
    }

    // optional bytes address = 14;
    if (has_address()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->address());
    }

    // optional uint32 bandwidth = 15;
    if (has_bandwidth()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->bandwidth());
    }

    // optional uint32 onlinesecs = 16;
    if (has_onlinesecs()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->onlinesecs());
    }

  }
  if (_has_bits_[16 / 32] & 458752) {
    // optional uint32 idlesecs = 17;
    if (has_idlesecs()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->idlesecs());
    }

    // optional bool strong_certificate = 18 [default = false];
    if (has_strong_certificate()) {
      total_size += 2 + 1;
    }

    // optional bool opus = 19 [default = false];
    if (has_opus()) {
      total_size += 2 + 1;
    }

  }
  // repeated bytes certificates = 3;
  total_size += 1 * this->certificates_size();
  for (int i = 0; i < this->certificates_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->certificates(i));
  }

  // repeated int32 celt_versions = 13;
  {
    int data_size = 0;
    for (int i = 0; i < this->celt_versions_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->celt_versions(i));
    }
    total_size += 1 * this->celt_versions_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserStats::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UserStats*>(&from));
}

void UserStats::MergeFrom(const UserStats& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  certificates_.MergeFrom(from.certificates_);
  celt_versions_.MergeFrom(from.celt_versions_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_session()) {
      set_session(from.session());
    }
    if (from.has_stats_only()) {
      set_stats_only(from.stats_only());
    }
    if (from.has_from_client()) {
      mutable_from_client()->::MumbleProto::UserStats_Stats::MergeFrom(from.from_client());
    }
    if (from.has_from_server()) {
      mutable_from_server()->::MumbleProto::UserStats_Stats::MergeFrom(from.from_server());
    }
    if (from.has_udp_packets()) {
      set_udp_packets(from.udp_packets());
    }
    if (from.has_tcp_packets()) {
      set_tcp_packets(from.tcp_packets());
    }
    if (from.has_udp_ping_avg()) {
      set_udp_ping_avg(from.udp_ping_avg());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_udp_ping_var()) {
      set_udp_ping_var(from.udp_ping_var());
    }
    if (from.has_tcp_ping_avg()) {
      set_tcp_ping_avg(from.tcp_ping_avg());
    }
    if (from.has_tcp_ping_var()) {
      set_tcp_ping_var(from.tcp_ping_var());
    }
    if (from.has_version()) {
      mutable_version()->::MumbleProto::Version::MergeFrom(from.version());
    }
    if (from.has_address()) {
      set_has_address();
      address_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.address_);
    }
    if (from.has_bandwidth()) {
      set_bandwidth(from.bandwidth());
    }
    if (from.has_onlinesecs()) {
      set_onlinesecs(from.onlinesecs());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_idlesecs()) {
      set_idlesecs(from.idlesecs());
    }
    if (from.has_strong_certificate()) {
      set_strong_certificate(from.strong_certificate());
    }
    if (from.has_opus()) {
      set_opus(from.opus());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UserStats::CopyFrom(const UserStats& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserStats::IsInitialized() const {

  return true;
}

void UserStats::Swap(UserStats* other) {
  if (other == this) return;
  InternalSwap(other);
}
void UserStats::InternalSwap(UserStats* other) {
  std::swap(session_, other->session_);
  std::swap(stats_only_, other->stats_only_);
  certificates_.UnsafeArenaSwap(&other->certificates_);
  std::swap(from_client_, other->from_client_);
  std::swap(from_server_, other->from_server_);
  std::swap(udp_packets_, other->udp_packets_);
  std::swap(tcp_packets_, other->tcp_packets_);
  std::swap(udp_ping_avg_, other->udp_ping_avg_);
  std::swap(udp_ping_var_, other->udp_ping_var_);
  std::swap(tcp_ping_avg_, other->tcp_ping_avg_);
  std::swap(tcp_ping_var_, other->tcp_ping_var_);
  std::swap(version_, other->version_);
  celt_versions_.UnsafeArenaSwap(&other->celt_versions_);
  address_.Swap(&other->address_);
  std::swap(bandwidth_, other->bandwidth_);
  std::swap(onlinesecs_, other->onlinesecs_);
  std::swap(idlesecs_, other->idlesecs_);
  std::swap(strong_certificate_, other->strong_certificate_);
  std::swap(opus_, other->opus_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string UserStats::GetTypeName() const {
  return "MumbleProto.UserStats";
}


// ===================================================================

#ifndef _MSC_VER
const int RequestBlob::kSessionTextureFieldNumber;
const int RequestBlob::kSessionCommentFieldNumber;
const int RequestBlob::kChannelDescriptionFieldNumber;
#endif  // !_MSC_VER

RequestBlob::RequestBlob()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.RequestBlob)
}

void RequestBlob::InitAsDefaultInstance() {
}

RequestBlob::RequestBlob(const RequestBlob& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.RequestBlob)
}

void RequestBlob::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RequestBlob::~RequestBlob() {
  // @@protoc_insertion_point(destructor:MumbleProto.RequestBlob)
  SharedDtor();
}

void RequestBlob::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void RequestBlob::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RequestBlob& RequestBlob::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

RequestBlob* RequestBlob::default_instance_ = NULL;

RequestBlob* RequestBlob::New(::google::protobuf::Arena* arena) const {
  RequestBlob* n = new RequestBlob;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RequestBlob::Clear() {
  session_texture_.Clear();
  session_comment_.Clear();
  channel_description_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool RequestBlob::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.RequestBlob)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 session_texture = 1;
      case 1: {
        if (tag == 8) {
         parse_session_texture:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 8, input, this->mutable_session_texture())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_session_texture())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_session_texture;
        if (input->ExpectTag(16)) goto parse_session_comment;
        break;
      }

      // repeated uint32 session_comment = 2;
      case 2: {
        if (tag == 16) {
         parse_session_comment:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 16, input, this->mutable_session_comment())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_session_comment())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_session_comment;
        if (input->ExpectTag(24)) goto parse_channel_description;
        break;
      }

      // repeated uint32 channel_description = 3;
      case 3: {
        if (tag == 24) {
         parse_channel_description:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 24, input, this->mutable_channel_description())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_channel_description())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_channel_description;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.RequestBlob)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.RequestBlob)
  return false;
#undef DO_
}

void RequestBlob::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.RequestBlob)
  // repeated uint32 session_texture = 1;
  for (int i = 0; i < this->session_texture_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      1, this->session_texture(i), output);
  }

  // repeated uint32 session_comment = 2;
  for (int i = 0; i < this->session_comment_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      2, this->session_comment(i), output);
  }

  // repeated uint32 channel_description = 3;
  for (int i = 0; i < this->channel_description_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      3, this->channel_description(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.RequestBlob)
}

int RequestBlob::ByteSize() const {
  int total_size = 0;

  // repeated uint32 session_texture = 1;
  {
    int data_size = 0;
    for (int i = 0; i < this->session_texture_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->session_texture(i));
    }
    total_size += 1 * this->session_texture_size() + data_size;
  }

  // repeated uint32 session_comment = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->session_comment_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->session_comment(i));
    }
    total_size += 1 * this->session_comment_size() + data_size;
  }

  // repeated uint32 channel_description = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->channel_description_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->channel_description(i));
    }
    total_size += 1 * this->channel_description_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RequestBlob::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RequestBlob*>(&from));
}

void RequestBlob::MergeFrom(const RequestBlob& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  session_texture_.MergeFrom(from.session_texture_);
  session_comment_.MergeFrom(from.session_comment_);
  channel_description_.MergeFrom(from.channel_description_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void RequestBlob::CopyFrom(const RequestBlob& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestBlob::IsInitialized() const {

  return true;
}

void RequestBlob::Swap(RequestBlob* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RequestBlob::InternalSwap(RequestBlob* other) {
  session_texture_.UnsafeArenaSwap(&other->session_texture_);
  session_comment_.UnsafeArenaSwap(&other->session_comment_);
  channel_description_.UnsafeArenaSwap(&other->channel_description_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RequestBlob::GetTypeName() const {
  return "MumbleProto.RequestBlob";
}


// ===================================================================

#ifndef _MSC_VER
const int ServerConfig::kMaxBandwidthFieldNumber;
const int ServerConfig::kWelcomeTextFieldNumber;
const int ServerConfig::kAllowHtmlFieldNumber;
const int ServerConfig::kMessageLengthFieldNumber;
const int ServerConfig::kImageMessageLengthFieldNumber;
#endif  // !_MSC_VER

ServerConfig::ServerConfig()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.ServerConfig)
}

void ServerConfig::InitAsDefaultInstance() {
}

ServerConfig::ServerConfig(const ServerConfig& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.ServerConfig)
}

void ServerConfig::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  max_bandwidth_ = 0u;
  welcome_text_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  allow_html_ = false;
  message_length_ = 0u;
  image_message_length_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ServerConfig::~ServerConfig() {
  // @@protoc_insertion_point(destructor:MumbleProto.ServerConfig)
  SharedDtor();
}

void ServerConfig::SharedDtor() {
  welcome_text_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ServerConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ServerConfig& ServerConfig::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

ServerConfig* ServerConfig::default_instance_ = NULL;

ServerConfig* ServerConfig::New(::google::protobuf::Arena* arena) const {
  ServerConfig* n = new ServerConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ServerConfig::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ServerConfig*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(max_bandwidth_, image_message_length_);
    if (has_welcome_text()) {
      welcome_text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ServerConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.ServerConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 max_bandwidth = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_bandwidth_)));
          set_has_max_bandwidth();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_welcome_text;
        break;
      }

      // optional string welcome_text = 2;
      case 2: {
        if (tag == 18) {
         parse_welcome_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_welcome_text()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_allow_html;
        break;
      }

      // optional bool allow_html = 3;
      case 3: {
        if (tag == 24) {
         parse_allow_html:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &allow_html_)));
          set_has_allow_html();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_message_length;
        break;
      }

      // optional uint32 message_length = 4;
      case 4: {
        if (tag == 32) {
         parse_message_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &message_length_)));
          set_has_message_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_image_message_length;
        break;
      }

      // optional uint32 image_message_length = 5;
      case 5: {
        if (tag == 40) {
         parse_image_message_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &image_message_length_)));
          set_has_image_message_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.ServerConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.ServerConfig)
  return false;
#undef DO_
}

void ServerConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.ServerConfig)
  // optional uint32 max_bandwidth = 1;
  if (has_max_bandwidth()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_bandwidth(), output);
  }

  // optional string welcome_text = 2;
  if (has_welcome_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->welcome_text(), output);
  }

  // optional bool allow_html = 3;
  if (has_allow_html()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->allow_html(), output);
  }

  // optional uint32 message_length = 4;
  if (has_message_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->message_length(), output);
  }

  // optional uint32 image_message_length = 5;
  if (has_image_message_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->image_message_length(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.ServerConfig)
}

int ServerConfig::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 31) {
    // optional uint32 max_bandwidth = 1;
    if (has_max_bandwidth()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_bandwidth());
    }

    // optional string welcome_text = 2;
    if (has_welcome_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->welcome_text());
    }

    // optional bool allow_html = 3;
    if (has_allow_html()) {
      total_size += 1 + 1;
    }

    // optional uint32 message_length = 4;
    if (has_message_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->message_length());
    }

    // optional uint32 image_message_length = 5;
    if (has_image_message_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->image_message_length());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ServerConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ServerConfig*>(&from));
}

void ServerConfig::MergeFrom(const ServerConfig& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_max_bandwidth()) {
      set_max_bandwidth(from.max_bandwidth());
    }
    if (from.has_welcome_text()) {
      set_has_welcome_text();
      welcome_text_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.welcome_text_);
    }
    if (from.has_allow_html()) {
      set_allow_html(from.allow_html());
    }
    if (from.has_message_length()) {
      set_message_length(from.message_length());
    }
    if (from.has_image_message_length()) {
      set_image_message_length(from.image_message_length());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ServerConfig::CopyFrom(const ServerConfig& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ServerConfig::IsInitialized() const {

  return true;
}

void ServerConfig::Swap(ServerConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ServerConfig::InternalSwap(ServerConfig* other) {
  std::swap(max_bandwidth_, other->max_bandwidth_);
  welcome_text_.Swap(&other->welcome_text_);
  std::swap(allow_html_, other->allow_html_);
  std::swap(message_length_, other->message_length_);
  std::swap(image_message_length_, other->image_message_length_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ServerConfig::GetTypeName() const {
  return "MumbleProto.ServerConfig";
}


// ===================================================================

#ifndef _MSC_VER
const int SuggestConfig::kVersionFieldNumber;
const int SuggestConfig::kPositionalFieldNumber;
const int SuggestConfig::kPushToTalkFieldNumber;
#endif  // !_MSC_VER

SuggestConfig::SuggestConfig()
  : ::google::protobuf::MessageLite() , _arena_ptr_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MumbleProto.SuggestConfig)
}

void SuggestConfig::InitAsDefaultInstance() {
}

SuggestConfig::SuggestConfig(const SuggestConfig& from)
  : ::google::protobuf::MessageLite(),
    _arena_ptr_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MumbleProto.SuggestConfig)
}

void SuggestConfig::SharedCtor() {
  _cached_size_ = 0;
  version_ = 0u;
  positional_ = false;
  push_to_talk_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SuggestConfig::~SuggestConfig() {
  // @@protoc_insertion_point(destructor:MumbleProto.SuggestConfig)
  SharedDtor();
}

void SuggestConfig::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void SuggestConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const SuggestConfig& SuggestConfig::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_mumble_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_mumble_2eproto();
#endif
  return *default_instance_;
}

SuggestConfig* SuggestConfig::default_instance_ = NULL;

SuggestConfig* SuggestConfig::New(::google::protobuf::Arena* arena) const {
  SuggestConfig* n = new SuggestConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SuggestConfig::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<SuggestConfig*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(version_, push_to_talk_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool SuggestConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MumbleProto.SuggestConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 version = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &version_)));
          set_has_version();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_positional;
        break;
      }

      // optional bool positional = 2;
      case 2: {
        if (tag == 16) {
         parse_positional:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &positional_)));
          set_has_positional();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_push_to_talk;
        break;
      }

      // optional bool push_to_talk = 3;
      case 3: {
        if (tag == 24) {
         parse_push_to_talk:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &push_to_talk_)));
          set_has_push_to_talk();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MumbleProto.SuggestConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MumbleProto.SuggestConfig)
  return false;
#undef DO_
}

void SuggestConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MumbleProto.SuggestConfig)
  // optional uint32 version = 1;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->version(), output);
  }

  // optional bool positional = 2;
  if (has_positional()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->positional(), output);
  }

  // optional bool push_to_talk = 3;
  if (has_push_to_talk()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->push_to_talk(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MumbleProto.SuggestConfig)
}

int SuggestConfig::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 7) {
    // optional uint32 version = 1;
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->version());
    }

    // optional bool positional = 2;
    if (has_positional()) {
      total_size += 1 + 1;
    }

    // optional bool push_to_talk = 3;
    if (has_push_to_talk()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SuggestConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const SuggestConfig*>(&from));
}

void SuggestConfig::MergeFrom(const SuggestConfig& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_positional()) {
      set_positional(from.positional());
    }
    if (from.has_push_to_talk()) {
      set_push_to_talk(from.push_to_talk());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void SuggestConfig::CopyFrom(const SuggestConfig& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SuggestConfig::IsInitialized() const {

  return true;
}

void SuggestConfig::Swap(SuggestConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SuggestConfig::InternalSwap(SuggestConfig* other) {
  std::swap(version_, other->version_);
  std::swap(positional_, other->positional_);
  std::swap(push_to_talk_, other->push_to_talk_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _unknown_fields_.swap(other->_unknown_fields_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string SuggestConfig::GetTypeName() const {
  return "MumbleProto.SuggestConfig";
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace MumbleProto

// @@protoc_insertion_point(global_scope)
