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

#include "remotecontrolmessages.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace cpb {
namespace remote {
constexpr SongMetadata::SongMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : title_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , album_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , artist_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , albumartist_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , pretty_year_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , genre_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , pretty_length_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , art_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , filename_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , url_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , art_automatic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , art_manual_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , id_(0)
  , index_(0)
  , track_(0)
  , disc_(0)
  , playcount_(0)
  , length_(0)
  , is_local_(false)
  , file_size_(0)
  , rating_(0)
  , type_(0)
{}
struct SongMetadataDefaultTypeInternal {
  constexpr SongMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SongMetadataDefaultTypeInternal() {}
  union {
    SongMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SongMetadataDefaultTypeInternal _SongMetadata_default_instance_;
constexpr Playlist::Playlist(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , id_(0)
  , item_count_(0)
  , active_(false)
  , closed_(false)
  , favorite_(false){}
struct PlaylistDefaultTypeInternal {
  constexpr PlaylistDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PlaylistDefaultTypeInternal() {}
  union {
    Playlist _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlaylistDefaultTypeInternal _Playlist_default_instance_;
constexpr RequestPlaylists::RequestPlaylists(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : include_closed_(false){}
struct RequestPlaylistsDefaultTypeInternal {
  constexpr RequestPlaylistsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestPlaylistsDefaultTypeInternal() {}
  union {
    RequestPlaylists _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestPlaylistsDefaultTypeInternal _RequestPlaylists_default_instance_;
constexpr RequestPlaylistSongs::RequestPlaylistSongs(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : id_(0){}
struct RequestPlaylistSongsDefaultTypeInternal {
  constexpr RequestPlaylistSongsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestPlaylistSongsDefaultTypeInternal() {}
  union {
    RequestPlaylistSongs _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestPlaylistSongsDefaultTypeInternal _RequestPlaylistSongs_default_instance_;
constexpr RequestChangeSong::RequestChangeSong(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : playlist_id_(0)
  , song_index_(0){}
struct RequestChangeSongDefaultTypeInternal {
  constexpr RequestChangeSongDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestChangeSongDefaultTypeInternal() {}
  union {
    RequestChangeSong _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestChangeSongDefaultTypeInternal _RequestChangeSong_default_instance_;
constexpr RequestSetVolume::RequestSetVolume(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : volume_(0){}
struct RequestSetVolumeDefaultTypeInternal {
  constexpr RequestSetVolumeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestSetVolumeDefaultTypeInternal() {}
  union {
    RequestSetVolume _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestSetVolumeDefaultTypeInternal _RequestSetVolume_default_instance_;
constexpr Repeat::Repeat(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : repeat_mode_(0)
{}
struct RepeatDefaultTypeInternal {
  constexpr RepeatDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RepeatDefaultTypeInternal() {}
  union {
    Repeat _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RepeatDefaultTypeInternal _Repeat_default_instance_;
constexpr Shuffle::Shuffle(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : shuffle_mode_(0)
{}
struct ShuffleDefaultTypeInternal {
  constexpr ShuffleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ShuffleDefaultTypeInternal() {}
  union {
    Shuffle _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ShuffleDefaultTypeInternal _Shuffle_default_instance_;
constexpr ResponseClementineInfo::ResponseClementineInfo(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : files_music_extensions_()
  , version_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , state_(0)

  , allow_downloads_(false){}
struct ResponseClementineInfoDefaultTypeInternal {
  constexpr ResponseClementineInfoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseClementineInfoDefaultTypeInternal() {}
  union {
    ResponseClementineInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseClementineInfoDefaultTypeInternal _ResponseClementineInfo_default_instance_;
constexpr ResponseCurrentMetadata::ResponseCurrentMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : song_metadata_(nullptr){}
struct ResponseCurrentMetadataDefaultTypeInternal {
  constexpr ResponseCurrentMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseCurrentMetadataDefaultTypeInternal() {}
  union {
    ResponseCurrentMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseCurrentMetadataDefaultTypeInternal _ResponseCurrentMetadata_default_instance_;
constexpr ResponsePlaylists::ResponsePlaylists(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : playlist_()
  , include_closed_(false){}
struct ResponsePlaylistsDefaultTypeInternal {
  constexpr ResponsePlaylistsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponsePlaylistsDefaultTypeInternal() {}
  union {
    ResponsePlaylists _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponsePlaylistsDefaultTypeInternal _ResponsePlaylists_default_instance_;
constexpr ResponsePlaylistSongs::ResponsePlaylistSongs(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : songs_()
  , requested_playlist_(nullptr){}
struct ResponsePlaylistSongsDefaultTypeInternal {
  constexpr ResponsePlaylistSongsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponsePlaylistSongsDefaultTypeInternal() {}
  union {
    ResponsePlaylistSongs _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponsePlaylistSongsDefaultTypeInternal _ResponsePlaylistSongs_default_instance_;
constexpr ResponseEngineStateChanged::ResponseEngineStateChanged(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : state_(0)
{}
struct ResponseEngineStateChangedDefaultTypeInternal {
  constexpr ResponseEngineStateChangedDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseEngineStateChangedDefaultTypeInternal() {}
  union {
    ResponseEngineStateChanged _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseEngineStateChangedDefaultTypeInternal _ResponseEngineStateChanged_default_instance_;
constexpr ResponseUpdateTrackPosition::ResponseUpdateTrackPosition(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : position_(0){}
struct ResponseUpdateTrackPositionDefaultTypeInternal {
  constexpr ResponseUpdateTrackPositionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseUpdateTrackPositionDefaultTypeInternal() {}
  union {
    ResponseUpdateTrackPosition _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseUpdateTrackPositionDefaultTypeInternal _ResponseUpdateTrackPosition_default_instance_;
constexpr RequestConnect::RequestConnect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : auth_code_(0)
  , send_playlist_songs_(false)
  , downloader_(false){}
struct RequestConnectDefaultTypeInternal {
  constexpr RequestConnectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestConnectDefaultTypeInternal() {}
  union {
    RequestConnect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestConnectDefaultTypeInternal _RequestConnect_default_instance_;
constexpr ResponseDisconnect::ResponseDisconnect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : reason_disconnect_(1)
{}
struct ResponseDisconnectDefaultTypeInternal {
  constexpr ResponseDisconnectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseDisconnectDefaultTypeInternal() {}
  union {
    ResponseDisconnect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseDisconnectDefaultTypeInternal _ResponseDisconnect_default_instance_;
constexpr ResponseActiveChanged::ResponseActiveChanged(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : id_(0){}
struct ResponseActiveChangedDefaultTypeInternal {
  constexpr ResponseActiveChangedDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseActiveChangedDefaultTypeInternal() {}
  union {
    ResponseActiveChanged _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseActiveChangedDefaultTypeInternal _ResponseActiveChanged_default_instance_;
constexpr RequestSetTrackPosition::RequestSetTrackPosition(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : position_(0){}
struct RequestSetTrackPositionDefaultTypeInternal {
  constexpr RequestSetTrackPositionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestSetTrackPositionDefaultTypeInternal() {}
  union {
    RequestSetTrackPosition _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestSetTrackPositionDefaultTypeInternal _RequestSetTrackPosition_default_instance_;
constexpr RequestInsertUrls::RequestInsertUrls(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : urls_()
  , songs_()
  , new_playlist_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , playlist_id_(0)
  , play_now_(false)
  , enqueue_(false)
  , position_(-1){}
struct RequestInsertUrlsDefaultTypeInternal {
  constexpr RequestInsertUrlsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestInsertUrlsDefaultTypeInternal() {}
  union {
    RequestInsertUrls _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestInsertUrlsDefaultTypeInternal _RequestInsertUrls_default_instance_;
constexpr RequestRemoveSongs::RequestRemoveSongs(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : songs_()
  , playlist_id_(0){}
struct RequestRemoveSongsDefaultTypeInternal {
  constexpr RequestRemoveSongsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestRemoveSongsDefaultTypeInternal() {}
  union {
    RequestRemoveSongs _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestRemoveSongsDefaultTypeInternal _RequestRemoveSongs_default_instance_;
constexpr RequestOpenPlaylist::RequestOpenPlaylist(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : playlist_id_(0){}
struct RequestOpenPlaylistDefaultTypeInternal {
  constexpr RequestOpenPlaylistDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestOpenPlaylistDefaultTypeInternal() {}
  union {
    RequestOpenPlaylist _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestOpenPlaylistDefaultTypeInternal _RequestOpenPlaylist_default_instance_;
constexpr RequestClosePlaylist::RequestClosePlaylist(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : playlist_id_(0){}
struct RequestClosePlaylistDefaultTypeInternal {
  constexpr RequestClosePlaylistDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestClosePlaylistDefaultTypeInternal() {}
  union {
    RequestClosePlaylist _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestClosePlaylistDefaultTypeInternal _RequestClosePlaylist_default_instance_;
constexpr RequestUpdatePlaylist::RequestUpdatePlaylist(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : new_playlist_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , playlist_id_(0)
  , favorite_(false)
  , create_new_playlist_(false)
  , clear_playlist_(false){}
struct RequestUpdatePlaylistDefaultTypeInternal {
  constexpr RequestUpdatePlaylistDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestUpdatePlaylistDefaultTypeInternal() {}
  union {
    RequestUpdatePlaylist _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestUpdatePlaylistDefaultTypeInternal _RequestUpdatePlaylist_default_instance_;
constexpr ResponseLyrics::ResponseLyrics(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : lyrics_(){}
struct ResponseLyricsDefaultTypeInternal {
  constexpr ResponseLyricsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseLyricsDefaultTypeInternal() {}
  union {
    ResponseLyrics _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseLyricsDefaultTypeInternal _ResponseLyrics_default_instance_;
constexpr Lyric::Lyric(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , title_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , content_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct LyricDefaultTypeInternal {
  constexpr LyricDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LyricDefaultTypeInternal() {}
  union {
    Lyric _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LyricDefaultTypeInternal _Lyric_default_instance_;
constexpr RequestDownloadSongs::RequestDownloadSongs(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : urls_()
  , songs_ids_()
  , relative_path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , playlist_id_(0)
  , download_item_(1)
{}
struct RequestDownloadSongsDefaultTypeInternal {
  constexpr RequestDownloadSongsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestDownloadSongsDefaultTypeInternal() {}
  union {
    RequestDownloadSongs _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestDownloadSongsDefaultTypeInternal _RequestDownloadSongs_default_instance_;
constexpr ResponseSongFileChunk::ResponseSongFileChunk(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , file_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , song_metadata_(nullptr)
  , chunk_number_(0)
  , chunk_count_(0)
  , file_number_(0)
  , file_count_(0)
  , size_(0){}
struct ResponseSongFileChunkDefaultTypeInternal {
  constexpr ResponseSongFileChunkDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseSongFileChunkDefaultTypeInternal() {}
  union {
    ResponseSongFileChunk _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseSongFileChunkDefaultTypeInternal _ResponseSongFileChunk_default_instance_;
constexpr ResponseLibraryChunk::ResponseLibraryChunk(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , file_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , chunk_number_(0)
  , chunk_count_(0)
  , size_(0){}
struct ResponseLibraryChunkDefaultTypeInternal {
  constexpr ResponseLibraryChunkDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseLibraryChunkDefaultTypeInternal() {}
  union {
    ResponseLibraryChunk _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseLibraryChunkDefaultTypeInternal _ResponseLibraryChunk_default_instance_;
constexpr ResponseSongOffer::ResponseSongOffer(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : accepted_(false){}
struct ResponseSongOfferDefaultTypeInternal {
  constexpr ResponseSongOfferDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseSongOfferDefaultTypeInternal() {}
  union {
    ResponseSongOffer _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseSongOfferDefaultTypeInternal _ResponseSongOffer_default_instance_;
constexpr RequestRateSong::RequestRateSong(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rating_(0){}
struct RequestRateSongDefaultTypeInternal {
  constexpr RequestRateSongDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestRateSongDefaultTypeInternal() {}
  union {
    RequestRateSong _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestRateSongDefaultTypeInternal _RequestRateSong_default_instance_;
constexpr ResponseDownloadTotalSize::ResponseDownloadTotalSize(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : total_size_(0)
  , file_count_(0){}
struct ResponseDownloadTotalSizeDefaultTypeInternal {
  constexpr ResponseDownloadTotalSizeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseDownloadTotalSizeDefaultTypeInternal() {}
  union {
    ResponseDownloadTotalSize _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseDownloadTotalSizeDefaultTypeInternal _ResponseDownloadTotalSize_default_instance_;
constexpr RequestGlobalSearch::RequestGlobalSearch(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : query_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct RequestGlobalSearchDefaultTypeInternal {
  constexpr RequestGlobalSearchDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestGlobalSearchDefaultTypeInternal() {}
  union {
    RequestGlobalSearch _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestGlobalSearchDefaultTypeInternal _RequestGlobalSearch_default_instance_;
constexpr ResponseGlobalSearch::ResponseGlobalSearch(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : song_metadata_()
  , query_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , search_provider_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , search_provider_icon_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , id_(0){}
struct ResponseGlobalSearchDefaultTypeInternal {
  constexpr ResponseGlobalSearchDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseGlobalSearchDefaultTypeInternal() {}
  union {
    ResponseGlobalSearch _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseGlobalSearchDefaultTypeInternal _ResponseGlobalSearch_default_instance_;
constexpr ResponseTranscoderStatus::ResponseTranscoderStatus(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : processed_(0)
  , total_(0){}
struct ResponseTranscoderStatusDefaultTypeInternal {
  constexpr ResponseTranscoderStatusDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseTranscoderStatusDefaultTypeInternal() {}
  union {
    ResponseTranscoderStatus _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseTranscoderStatusDefaultTypeInternal _ResponseTranscoderStatus_default_instance_;
constexpr ResponseGlobalSearchStatus::ResponseGlobalSearchStatus(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : query_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , id_(0)
  , status_(1)
{}
struct ResponseGlobalSearchStatusDefaultTypeInternal {
  constexpr ResponseGlobalSearchStatusDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseGlobalSearchStatusDefaultTypeInternal() {}
  union {
    ResponseGlobalSearchStatus _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseGlobalSearchStatusDefaultTypeInternal _ResponseGlobalSearchStatus_default_instance_;
constexpr RequestListFiles::RequestListFiles(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : relative_path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct RequestListFilesDefaultTypeInternal {
  constexpr RequestListFilesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestListFilesDefaultTypeInternal() {}
  union {
    RequestListFiles _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestListFilesDefaultTypeInternal _RequestListFiles_default_instance_;
constexpr FileMetadata::FileMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : filename_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , is_dir_(false){}
struct FileMetadataDefaultTypeInternal {
  constexpr FileMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FileMetadataDefaultTypeInternal() {}
  union {
    FileMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FileMetadataDefaultTypeInternal _FileMetadata_default_instance_;
constexpr ResponseListFiles::ResponseListFiles(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : files_()
  , relative_path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , error_(0)
{}
struct ResponseListFilesDefaultTypeInternal {
  constexpr ResponseListFilesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseListFilesDefaultTypeInternal() {}
  union {
    ResponseListFiles _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseListFilesDefaultTypeInternal _ResponseListFiles_default_instance_;
constexpr RequestAppendFiles::RequestAppendFiles(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : files_()
  , new_playlist_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , relative_path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , playlist_id_(0)
  , play_now_(false)
  , clear_first_(false){}
struct RequestAppendFilesDefaultTypeInternal {
  constexpr RequestAppendFilesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RequestAppendFilesDefaultTypeInternal() {}
  union {
    RequestAppendFiles _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RequestAppendFilesDefaultTypeInternal _RequestAppendFiles_default_instance_;
constexpr Stream::Stream(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , url_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , url_logo_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct StreamDefaultTypeInternal {
  constexpr StreamDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~StreamDefaultTypeInternal() {}
  union {
    Stream _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StreamDefaultTypeInternal _Stream_default_instance_;
constexpr ResponseSavedRadios::ResponseSavedRadios(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : streams_(){}
struct ResponseSavedRadiosDefaultTypeInternal {
  constexpr ResponseSavedRadiosDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResponseSavedRadiosDefaultTypeInternal() {}
  union {
    ResponseSavedRadios _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResponseSavedRadiosDefaultTypeInternal _ResponseSavedRadios_default_instance_;
constexpr Message::Message(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : request_playlist_songs_(nullptr)
  , request_change_song_(nullptr)
  , request_set_volume_(nullptr)
  , repeat_(nullptr)
  , shuffle_(nullptr)
  , response_clementine_info_(nullptr)
  , response_current_metadata_(nullptr)
  , response_playlists_(nullptr)
  , response_playlist_songs_(nullptr)
  , response_engine_state_changed_(nullptr)
  , response_update_track_position_(nullptr)
  , request_connect_(nullptr)
  , response_disconnect_(nullptr)
  , request_set_track_position_(nullptr)
  , response_active_changed_(nullptr)
  , request_insert_urls_(nullptr)
  , request_remove_songs_(nullptr)
  , request_playlists_(nullptr)
  , request_open_playlist_(nullptr)
  , request_close_playlist_(nullptr)
  , response_lyrics_(nullptr)
  , request_download_songs_(nullptr)
  , response_song_file_chunk_(nullptr)
  , response_song_offer_(nullptr)
  , response_library_chunk_(nullptr)
  , request_rate_song_(nullptr)
  , response_download_total_size_(nullptr)
  , request_global_search_(nullptr)
  , response_global_search_(nullptr)
  , response_transcoder_status_(nullptr)
  , response_global_search_status_(nullptr)
  , request_list_files_(nullptr)
  , request_append_files_(nullptr)
  , response_list_files_(nullptr)
  , request_update_playlist_(nullptr)
  , response_saved_radios_(nullptr)
  , type_(0)

  , version_(21){}
struct MessageDefaultTypeInternal {
  constexpr MessageDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MessageDefaultTypeInternal() {}
  union {
    Message _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageDefaultTypeInternal _Message_default_instance_;
}  // namespace remote
}  // namespace cpb
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_remotecontrolmessages_2eproto[42];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_remotecontrolmessages_2eproto[9];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_remotecontrolmessages_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_remotecontrolmessages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, index_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, title_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, album_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, artist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, albumartist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, track_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, disc_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, pretty_year_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, genre_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, playcount_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, pretty_length_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, art_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, length_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, is_local_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, filename_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, file_size_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, rating_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, url_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, art_automatic_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, art_manual_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::SongMetadata, type_),
  12,
  13,
  0,
  1,
  2,
  3,
  14,
  15,
  4,
  5,
  16,
  6,
  7,
  17,
  18,
  8,
  19,
  20,
  9,
  10,
  11,
  21,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, name_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, item_count_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, active_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, closed_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Playlist, favorite_),
  1,
  0,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylists, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylists, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylists, include_closed_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylistSongs, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylistSongs, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestPlaylistSongs, id_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestChangeSong, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestChangeSong, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestChangeSong, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestChangeSong, song_index_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetVolume, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetVolume, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetVolume, volume_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Repeat, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Repeat, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Repeat, repeat_mode_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Shuffle, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Shuffle, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Shuffle, shuffle_mode_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, version_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, state_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, allow_downloads_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseClementineInfo, files_music_extensions_),
  0,
  1,
  2,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseCurrentMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseCurrentMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseCurrentMetadata, song_metadata_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylists, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylists, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylists, playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylists, include_closed_),
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylistSongs, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylistSongs, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylistSongs, requested_playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponsePlaylistSongs, songs_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseEngineStateChanged, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseEngineStateChanged, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseEngineStateChanged, state_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseUpdateTrackPosition, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseUpdateTrackPosition, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseUpdateTrackPosition, position_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestConnect, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestConnect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestConnect, auth_code_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestConnect, send_playlist_songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestConnect, downloader_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDisconnect, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDisconnect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDisconnect, reason_disconnect_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseActiveChanged, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseActiveChanged, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseActiveChanged, id_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetTrackPosition, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetTrackPosition, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestSetTrackPosition, position_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, urls_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, position_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, play_now_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, enqueue_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestInsertUrls, new_playlist_name_),
  1,
  ~0u,
  4,
  2,
  3,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRemoveSongs, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRemoveSongs, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRemoveSongs, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRemoveSongs, songs_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestOpenPlaylist, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestOpenPlaylist, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestOpenPlaylist, playlist_id_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestClosePlaylist, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestClosePlaylist, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestClosePlaylist, playlist_id_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, new_playlist_name_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, favorite_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, create_new_playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestUpdatePlaylist, clear_playlist_),
  1,
  0,
  2,
  3,
  4,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLyrics, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLyrics, lyrics_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Lyric, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Lyric, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Lyric, id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Lyric, title_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Lyric, content_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, download_item_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, urls_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, songs_ids_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestDownloadSongs, relative_path_),
  2,
  1,
  ~0u,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, chunk_number_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, chunk_count_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, file_number_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, file_count_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, song_metadata_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, data_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, size_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongFileChunk, file_hash_),
  3,
  4,
  5,
  6,
  2,
  0,
  7,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, chunk_number_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, chunk_count_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, data_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, size_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseLibraryChunk, file_hash_),
  2,
  3,
  0,
  4,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongOffer, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongOffer, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSongOffer, accepted_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRateSong, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRateSong, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestRateSong, rating_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDownloadTotalSize, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDownloadTotalSize, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDownloadTotalSize, total_size_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseDownloadTotalSize, file_count_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestGlobalSearch, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestGlobalSearch, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestGlobalSearch, query_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, query_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, search_provider_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, song_metadata_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearch, search_provider_icon_),
  3,
  0,
  1,
  ~0u,
  2,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseTranscoderStatus, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseTranscoderStatus, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseTranscoderStatus, processed_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseTranscoderStatus, total_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearchStatus, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearchStatus, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearchStatus, id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearchStatus, query_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseGlobalSearchStatus, status_),
  1,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestListFiles, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestListFiles, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestListFiles, relative_path_),
  0,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::FileMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::FileMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::FileMetadata, filename_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::FileMetadata, is_dir_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseListFiles, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseListFiles, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseListFiles, relative_path_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseListFiles, files_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseListFiles, error_),
  0,
  ~0u,
  1,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, playlist_id_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, new_playlist_name_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, relative_path_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, files_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, play_now_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::RequestAppendFiles, clear_first_),
  2,
  0,
  1,
  ~0u,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Stream, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Stream, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Stream, name_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Stream, url_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Stream, url_logo_),
  0,
  1,
  2,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSavedRadios, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::ResponseSavedRadios, streams_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, version_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, type_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_connect_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_playlists_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_playlist_songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_change_song_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_set_volume_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_set_track_position_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_insert_urls_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_remove_songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_open_playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_close_playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_update_playlist_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_download_songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_rate_song_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_global_search_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_list_files_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, request_append_files_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, repeat_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, shuffle_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_clementine_info_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_current_metadata_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_playlists_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_playlist_songs_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_engine_state_changed_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_update_track_position_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_disconnect_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_active_changed_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_lyrics_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_song_file_chunk_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_song_offer_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_library_chunk_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_download_total_size_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_global_search_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_transcoder_status_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_global_search_status_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_list_files_),
  PROTOBUF_FIELD_OFFSET(::cpb::remote::Message, response_saved_radios_),
  37,
  36,
  11,
  17,
  0,
  1,
  2,
  13,
  15,
  16,
  18,
  19,
  34,
  21,
  25,
  27,
  31,
  32,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  12,
  14,
  20,
  22,
  23,
  24,
  26,
  28,
  29,
  30,
  33,
  35,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 27, sizeof(::cpb::remote::SongMetadata)},
  { 49, 60, sizeof(::cpb::remote::Playlist)},
  { 66, 72, sizeof(::cpb::remote::RequestPlaylists)},
  { 73, 79, sizeof(::cpb::remote::RequestPlaylistSongs)},
  { 80, 87, sizeof(::cpb::remote::RequestChangeSong)},
  { 89, 95, sizeof(::cpb::remote::RequestSetVolume)},
  { 96, 102, sizeof(::cpb::remote::Repeat)},
  { 103, 109, sizeof(::cpb::remote::Shuffle)},
  { 110, 119, sizeof(::cpb::remote::ResponseClementineInfo)},
  { 123, 129, sizeof(::cpb::remote::ResponseCurrentMetadata)},
  { 130, 137, sizeof(::cpb::remote::ResponsePlaylists)},
  { 139, 146, sizeof(::cpb::remote::ResponsePlaylistSongs)},
  { 148, 154, sizeof(::cpb::remote::ResponseEngineStateChanged)},
  { 155, 161, sizeof(::cpb::remote::ResponseUpdateTrackPosition)},
  { 162, 170, sizeof(::cpb::remote::RequestConnect)},
  { 173, 179, sizeof(::cpb::remote::ResponseDisconnect)},
  { 180, 186, sizeof(::cpb::remote::ResponseActiveChanged)},
  { 187, 193, sizeof(::cpb::remote::RequestSetTrackPosition)},
  { 194, 206, sizeof(::cpb::remote::RequestInsertUrls)},
  { 213, 220, sizeof(::cpb::remote::RequestRemoveSongs)},
  { 222, 228, sizeof(::cpb::remote::RequestOpenPlaylist)},
  { 229, 235, sizeof(::cpb::remote::RequestClosePlaylist)},
  { 236, 246, sizeof(::cpb::remote::RequestUpdatePlaylist)},
  { 251, -1, sizeof(::cpb::remote::ResponseLyrics)},
  { 257, 265, sizeof(::cpb::remote::Lyric)},
  { 268, 278, sizeof(::cpb::remote::RequestDownloadSongs)},
  { 283, 296, sizeof(::cpb::remote::ResponseSongFileChunk)},
  { 304, 314, sizeof(::cpb::remote::ResponseLibraryChunk)},
  { 319, 325, sizeof(::cpb::remote::ResponseSongOffer)},
  { 326, 332, sizeof(::cpb::remote::RequestRateSong)},
  { 333, 340, sizeof(::cpb::remote::ResponseDownloadTotalSize)},
  { 342, 348, sizeof(::cpb::remote::RequestGlobalSearch)},
  { 349, 359, sizeof(::cpb::remote::ResponseGlobalSearch)},
  { 364, 371, sizeof(::cpb::remote::ResponseTranscoderStatus)},
  { 373, 381, sizeof(::cpb::remote::ResponseGlobalSearchStatus)},
  { 384, 390, sizeof(::cpb::remote::RequestListFiles)},
  { 391, 398, sizeof(::cpb::remote::FileMetadata)},
  { 400, 408, sizeof(::cpb::remote::ResponseListFiles)},
  { 411, 422, sizeof(::cpb::remote::RequestAppendFiles)},
  { 428, 436, sizeof(::cpb::remote::Stream)},
  { 439, -1, sizeof(::cpb::remote::ResponseSavedRadios)},
  { 445, 488, sizeof(::cpb::remote::Message)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_SongMetadata_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Playlist_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestPlaylists_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestPlaylistSongs_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestChangeSong_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestSetVolume_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Repeat_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Shuffle_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseClementineInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseCurrentMetadata_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponsePlaylists_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponsePlaylistSongs_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseEngineStateChanged_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseUpdateTrackPosition_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestConnect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseDisconnect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseActiveChanged_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestSetTrackPosition_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestInsertUrls_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestRemoveSongs_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestOpenPlaylist_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestClosePlaylist_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestUpdatePlaylist_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseLyrics_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Lyric_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestDownloadSongs_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseSongFileChunk_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseLibraryChunk_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseSongOffer_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestRateSong_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseDownloadTotalSize_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestGlobalSearch_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseGlobalSearch_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseTranscoderStatus_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseGlobalSearchStatus_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestListFiles_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_FileMetadata_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseListFiles_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_RequestAppendFiles_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Stream_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_ResponseSavedRadios_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::cpb::remote::_Message_default_instance_),
};

const char descriptor_table_protodef_remotecontrolmessages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\033remotecontrolmessages.proto\022\ncpb.remot"
  "e\"\374\004\n\014SongMetadata\022\n\n\002id\030\001 \001(\005\022\r\n\005index\030"
  "\002 \001(\005\022\r\n\005title\030\003 \001(\t\022\r\n\005album\030\004 \001(\t\022\016\n\006a"
  "rtist\030\005 \001(\t\022\023\n\013albumartist\030\006 \001(\t\022\r\n\005trac"
  "k\030\007 \001(\005\022\014\n\004disc\030\010 \001(\005\022\023\n\013pretty_year\030\t \001"
  "(\t\022\r\n\005genre\030\n \001(\t\022\021\n\tplaycount\030\013 \001(\005\022\025\n\r"
  "pretty_length\030\014 \001(\t\022\013\n\003art\030\r \001(\014\022\016\n\006leng"
  "th\030\016 \001(\005\022\020\n\010is_local\030\017 \001(\010\022\020\n\010filename\030\020"
  " \001(\t\022\021\n\tfile_size\030\021 \001(\005\022\016\n\006rating\030\022 \001(\002\022"
  "\013\n\003url\030\023 \001(\t\022\025\n\rart_automatic\030\024 \001(\t\022\022\n\na"
  "rt_manual\030\025 \001(\t\022+\n\004type\030\026 \001(\0162\035.cpb.remo"
  "te.SongMetadata.Type\"\331\001\n\004Type\022\013\n\007UNKNOWN"
  "\020\000\022\007\n\003ASF\020\001\022\010\n\004FLAC\020\002\022\007\n\003MP4\020\003\022\007\n\003MPC\020\004\022"
  "\010\n\004MPEG\020\005\022\013\n\007OGGFLAC\020\006\022\014\n\010OGGSPEEX\020\007\022\r\n\t"
  "OGGVORBIS\020\010\022\010\n\004AIFF\020\t\022\007\n\003WAV\020\n\022\r\n\tTRUEAU"
  "DIO\020\013\022\010\n\004CDDA\020\014\022\013\n\007OGGOPUS\020\r\022\013\n\007WAVPACK\020"
  "\016\022\007\n\003SPC\020\017\022\007\n\003VGM\020\020\022\007\n\003APE\020\021\022\n\n\006STREAM\020c"
  "\"j\n\010Playlist\022\n\n\002id\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\022\022"
  "\n\nitem_count\030\003 \001(\005\022\016\n\006active\030\004 \001(\010\022\016\n\006cl"
  "osed\030\005 \001(\010\022\020\n\010favorite\030\006 \001(\010\"*\n\020RequestP"
  "laylists\022\026\n\016include_closed\030\001 \001(\010\"\"\n\024Requ"
  "estPlaylistSongs\022\n\n\002id\030\001 \001(\005\"<\n\021RequestC"
  "hangeSong\022\023\n\013playlist_id\030\001 \001(\005\022\022\n\nsong_i"
  "ndex\030\002 \001(\005\"\"\n\020RequestSetVolume\022\016\n\006volume"
  "\030\001 \001(\005\"5\n\006Repeat\022+\n\013repeat_mode\030\001 \001(\0162\026."
  "cpb.remote.RepeatMode\"8\n\007Shuffle\022-\n\014shuf"
  "fle_mode\030\001 \001(\0162\027.cpb.remote.ShuffleMode\""
  "\212\001\n\026ResponseClementineInfo\022\017\n\007version\030\001 "
  "\001(\t\022&\n\005state\030\002 \001(\0162\027.cpb.remote.EngineSt"
  "ate\022\027\n\017allow_downloads\030\003 \001(\010\022\036\n\026files_mu"
  "sic_extensions\030\004 \003(\t\"J\n\027ResponseCurrentM"
  "etadata\022/\n\rsong_metadata\030\001 \001(\0132\030.cpb.rem"
  "ote.SongMetadata\"S\n\021ResponsePlaylists\022&\n"
  "\010playlist\030\001 \003(\0132\024.cpb.remote.Playlist\022\026\n"
  "\016include_closed\030\002 \001(\010\"r\n\025ResponsePlaylis"
  "tSongs\0220\n\022requested_playlist\030\001 \001(\0132\024.cpb"
  ".remote.Playlist\022\'\n\005songs\030\002 \003(\0132\030.cpb.re"
  "mote.SongMetadata\"D\n\032ResponseEngineState"
  "Changed\022&\n\005state\030\001 \001(\0162\027.cpb.remote.Engi"
  "neState\"/\n\033ResponseUpdateTrackPosition\022\020"
  "\n\010position\030\001 \001(\005\"T\n\016RequestConnect\022\021\n\tau"
  "th_code\030\001 \001(\005\022\033\n\023send_playlist_songs\030\002 \001"
  "(\010\022\022\n\ndownloader\030\003 \001(\010\"M\n\022ResponseDiscon"
  "nect\0227\n\021reason_disconnect\030\001 \001(\0162\034.cpb.re"
  "mote.ReasonDisconnect\"#\n\025ResponseActiveC"
  "hanged\022\n\n\002id\030\001 \001(\005\"+\n\027RequestSetTrackPos"
  "ition\022\020\n\010position\030\001 \001(\005\"\301\001\n\021RequestInser"
  "tUrls\022\023\n\013playlist_id\030\001 \001(\005\022\014\n\004urls\030\002 \003(\t"
  "\022\024\n\010position\030\003 \001(\005:\002-1\022\027\n\010play_now\030\004 \001(\010"
  ":\005false\022\026\n\007enqueue\030\005 \001(\010:\005false\022\'\n\005songs"
  "\030\006 \003(\0132\030.cpb.remote.SongMetadata\022\031\n\021new_"
  "playlist_name\030\007 \001(\t\"8\n\022RequestRemoveSong"
  "s\022\023\n\013playlist_id\030\001 \001(\005\022\r\n\005songs\030\002 \003(\005\"*\n"
  "\023RequestOpenPlaylist\022\023\n\013playlist_id\030\001 \001("
  "\005\"+\n\024RequestClosePlaylist\022\023\n\013playlist_id"
  "\030\001 \001(\005\"\216\001\n\025RequestUpdatePlaylist\022\023\n\013play"
  "list_id\030\001 \001(\005\022\031\n\021new_playlist_name\030\002 \001(\t"
  "\022\020\n\010favorite\030\003 \001(\010\022\033\n\023create_new_playlis"
  "t\030\004 \001(\010\022\026\n\016clear_playlist\030\005 \001(\010\"3\n\016Respo"
  "nseLyrics\022!\n\006lyrics\030\001 \003(\0132\021.cpb.remote.L"
  "yric\"3\n\005Lyric\022\n\n\002id\030\001 \001(\t\022\r\n\005title\030\002 \001(\t"
  "\022\017\n\007content\030\003 \001(\t\"\224\001\n\024RequestDownloadSon"
  "gs\022/\n\rdownload_item\030\001 \001(\0162\030.cpb.remote.D"
  "ownloadItem\022\023\n\013playlist_id\030\002 \001(\005\022\014\n\004urls"
  "\030\003 \003(\t\022\021\n\tsongs_ids\030\004 \003(\005\022\025\n\rrelative_pa"
  "th\030\005 \001(\t\"\313\001\n\025ResponseSongFileChunk\022\024\n\014ch"
  "unk_number\030\001 \001(\005\022\023\n\013chunk_count\030\002 \001(\005\022\023\n"
  "\013file_number\030\003 \001(\005\022\022\n\nfile_count\030\004 \001(\005\022/"
  "\n\rsong_metadata\030\006 \001(\0132\030.cpb.remote.SongM"
  "etadata\022\014\n\004data\030\007 \001(\014\022\014\n\004size\030\010 \001(\005\022\021\n\tf"
  "ile_hash\030\t \001(\014\"p\n\024ResponseLibraryChunk\022\024"
  "\n\014chunk_number\030\001 \001(\005\022\023\n\013chunk_count\030\002 \001("
  "\005\022\014\n\004data\030\003 \001(\014\022\014\n\004size\030\004 \001(\005\022\021\n\tfile_ha"
  "sh\030\005 \001(\014\"%\n\021ResponseSongOffer\022\020\n\010accepte"
  "d\030\001 \001(\010\"!\n\017RequestRateSong\022\016\n\006rating\030\001 \001"
  "(\002\"C\n\031ResponseDownloadTotalSize\022\022\n\ntotal"
  "_size\030\001 \001(\005\022\022\n\nfile_count\030\002 \001(\005\"$\n\023Reque"
  "stGlobalSearch\022\r\n\005query\030\001 \001(\t\"\231\001\n\024Respon"
  "seGlobalSearch\022\n\n\002id\030\001 \001(\005\022\r\n\005query\030\002 \001("
  "\t\022\027\n\017search_provider\030\003 \001(\t\022/\n\rsong_metad"
  "ata\030\004 \003(\0132\030.cpb.remote.SongMetadata\022\034\n\024s"
  "earch_provider_icon\030\005 \001(\014\"<\n\030ResponseTra"
  "nscoderStatus\022\021\n\tprocessed\030\001 \001(\005\022\r\n\005tota"
  "l\030\002 \001(\005\"g\n\032ResponseGlobalSearchStatus\022\n\n"
  "\002id\030\001 \001(\005\022\r\n\005query\030\002 \001(\t\022.\n\006status\030\003 \001(\016"
  "2\036.cpb.remote.GlobalSearchStatus\")\n\020Requ"
  "estListFiles\022\025\n\rrelative_path\030\001 \001(\t\"0\n\014F"
  "ileMetadata\022\020\n\010filename\030\001 \001(\t\022\016\n\006is_dir\030"
  "\002 \001(\010\"\350\001\n\021ResponseListFiles\022\025\n\rrelative_"
  "path\030\001 \001(\t\022\'\n\005files\030\002 \003(\0132\030.cpb.remote.F"
  "ileMetadata\0222\n\005error\030\003 \001(\0162#.cpb.remote."
  "ResponseListFiles.Error\"_\n\005Error\022\010\n\004NONE"
  "\020\000\022\024\n\020ROOT_DIR_NOT_SET\020\001\022\026\n\022DIR_NOT_ACCE"
  "SSIBLE\020\002\022\021\n\rDIR_NOT_EXIST\020\003\022\013\n\007UNKNOWN\020\004"
  "\"\221\001\n\022RequestAppendFiles\022\023\n\013playlist_id\030\001"
  " \001(\005\022\031\n\021new_playlist_name\030\002 \001(\t\022\025\n\rrelat"
  "ive_path\030\003 \001(\t\022\r\n\005files\030\004 \003(\t\022\020\n\010play_no"
  "w\030\005 \001(\010\022\023\n\013clear_first\030\006 \001(\010\"5\n\006Stream\022\014"
  "\n\004name\030\001 \001(\t\022\013\n\003url\030\002 \001(\t\022\020\n\010url_logo\030\003 "
  "\001(\t\":\n\023ResponseSavedRadios\022#\n\007streams\030\001 "
  "\003(\0132\022.cpb.remote.Stream\"\277\022\n\007Message\022\023\n\007v"
  "ersion\030\001 \001(\005:\00221\022*\n\004type\030\002 \001(\0162\023.cpb.rem"
  "ote.MsgType:\007UNKNOWN\0223\n\017request_connect\030"
  "\025 \001(\0132\032.cpb.remote.RequestConnect\0227\n\021req"
  "uest_playlists\030\033 \001(\0132\034.cpb.remote.Reques"
  "tPlaylists\022@\n\026request_playlist_songs\030\n \001"
  "(\0132 .cpb.remote.RequestPlaylistSongs\022:\n\023"
  "request_change_song\030\013 \001(\0132\035.cpb.remote.R"
  "equestChangeSong\0228\n\022request_set_volume\030\014"
  " \001(\0132\034.cpb.remote.RequestSetVolume\022G\n\032re"
  "quest_set_track_position\030\027 \001(\0132#.cpb.rem"
  "ote.RequestSetTrackPosition\022:\n\023request_i"
  "nsert_urls\030\031 \001(\0132\035.cpb.remote.RequestIns"
  "ertUrls\022<\n\024request_remove_songs\030\032 \001(\0132\036."
  "cpb.remote.RequestRemoveSongs\022>\n\025request"
  "_open_playlist\030\034 \001(\0132\037.cpb.remote.Reques"
  "tOpenPlaylist\022@\n\026request_close_playlist\030"
  "\035 \001(\0132 .cpb.remote.RequestClosePlaylist\022"
  "B\n\027request_update_playlist\0305 \001(\0132!.cpb.r"
  "emote.RequestUpdatePlaylist\022@\n\026request_d"
  "ownload_songs\030\037 \001(\0132 .cpb.remote.Request"
  "DownloadSongs\0226\n\021request_rate_song\030# \001(\013"
  "2\033.cpb.remote.RequestRateSong\022>\n\025request"
  "_global_search\030% \001(\0132\037.cpb.remote.Reques"
  "tGlobalSearch\0228\n\022request_list_files\0302 \001("
  "\0132\034.cpb.remote.RequestListFiles\022<\n\024reque"
  "st_append_files\0303 \001(\0132\036.cpb.remote.Reque"
  "stAppendFiles\022\"\n\006repeat\030\r \001(\0132\022.cpb.remo"
  "te.Repeat\022$\n\007shuffle\030\016 \001(\0132\023.cpb.remote."
  "Shuffle\022D\n\030response_clementine_info\030\017 \001("
  "\0132\".cpb.remote.ResponseClementineInfo\022F\n"
  "\031response_current_metadata\030\020 \001(\0132#.cpb.r"
  "emote.ResponseCurrentMetadata\0229\n\022respons"
  "e_playlists\030\021 \001(\0132\035.cpb.remote.ResponseP"
  "laylists\022B\n\027response_playlist_songs\030\022 \001("
  "\0132!.cpb.remote.ResponsePlaylistSongs\022M\n\035"
  "response_engine_state_changed\030\023 \001(\0132&.cp"
  "b.remote.ResponseEngineStateChanged\022O\n\036r"
  "esponse_update_track_position\030\024 \001(\0132\'.cp"
  "b.remote.ResponseUpdateTrackPosition\022;\n\023"
  "response_disconnect\030\026 \001(\0132\036.cpb.remote.R"
  "esponseDisconnect\022B\n\027response_active_cha"
  "nged\030\030 \001(\0132!.cpb.remote.ResponseActiveCh"
  "anged\0223\n\017response_lyrics\030\036 \001(\0132\032.cpb.rem"
  "ote.ResponseLyrics\022C\n\030response_song_file"
  "_chunk\030  \001(\0132!.cpb.remote.ResponseSongFi"
  "leChunk\022:\n\023response_song_offer\030! \001(\0132\035.c"
  "pb.remote.ResponseSongOffer\022@\n\026response_"
  "library_chunk\030\" \001(\0132 .cpb.remote.Respons"
  "eLibraryChunk\022K\n\034response_download_total"
  "_size\030$ \001(\0132%.cpb.remote.ResponseDownloa"
  "dTotalSize\022@\n\026response_global_search\030& \001"
  "(\0132 .cpb.remote.ResponseGlobalSearch\022H\n\032"
  "response_transcoder_status\030\' \001(\0132$.cpb.r"
  "emote.ResponseTranscoderStatus\022M\n\035respon"
  "se_global_search_status\030( \001(\0132&.cpb.remo"
  "te.ResponseGlobalSearchStatus\022:\n\023respons"
  "e_list_files\0304 \001(\0132\035.cpb.remote.Response"
  "ListFiles\022>\n\025response_saved_radios\0306 \001(\013"
  "2\037.cpb.remote.ResponseSavedRadios*\315\007\n\007Ms"
  "gType\022\013\n\007UNKNOWN\020\000\022\013\n\007CONNECT\020\001\022\025\n\021REQUE"
  "ST_PLAYLISTS\020\003\022\032\n\026REQUEST_PLAYLIST_SONGS"
  "\020\004\022\017\n\013CHANGE_SONG\020\005\022\016\n\nSET_VOLUME\020\006\022\026\n\022S"
  "ET_TRACK_POSITION\020\007\022\017\n\013INSERT_URLS\020\010\022\020\n\014"
  "REMOVE_SONGS\020\t\022\021\n\rOPEN_PLAYLIST\020\n\022\022\n\016CLO"
  "SE_PLAYLIST\020\013\022\023\n\017UPDATE_PLAYLIST\020<\022\016\n\nGE"
  "T_LYRICS\020\016\022\022\n\016DOWNLOAD_SONGS\020\017\022\027\n\023SONG_O"
  "FFER_RESPONSE\020\020\022\010\n\004LOVE\020\014\022\007\n\003BAN\020\r\022\016\n\nST"
  "OP_AFTER\020\021\022\017\n\013GET_LIBRARY\020\022\022\r\n\tRATE_SONG"
  "\020\023\022\021\n\rGLOBAL_SEARCH\020d\022\030\n\024REQUEST_SAVED_R"
  "ADIOS\020n\022\022\n\rREQUEST_FILES\020\310\001\022\021\n\014APPEND_FI"
  "LES\020\311\001\022\016\n\nDISCONNECT\020\002\022\010\n\004PLAY\020\024\022\r\n\tPLAY"
  "PAUSE\020\025\022\t\n\005PAUSE\020\026\022\010\n\004STOP\020\027\022\010\n\004NEXT\020\030\022\014"
  "\n\010PREVIOUS\020\031\022\024\n\020SHUFFLE_PLAYLIST\020\032\022\n\n\006RE"
  "PEAT\020\033\022\013\n\007SHUFFLE\020\034\022\010\n\004INFO\020(\022\024\n\020CURRENT"
  "_METAINFO\020)\022\r\n\tPLAYLISTS\020*\022\022\n\016PLAYLIST_S"
  "ONGS\020+\022\030\n\024ENGINE_STATE_CHANGED\020,\022\016\n\nKEEP"
  "_ALIVE\020-\022\031\n\025UPDATE_TRACK_POSITION\020.\022\033\n\027A"
  "CTIVE_PLAYLIST_CHANGED\020/\022\034\n\030FIRST_DATA_S"
  "ENT_COMPLETE\0200\022\n\n\006LYRICS\0201\022\023\n\017SONG_FILE_"
  "CHUNK\0202\022\030\n\024DOWNLOAD_QUEUE_EMPTY\0203\022\021\n\rLIB"
  "RARY_CHUNK\0204\022\027\n\023DOWNLOAD_TOTAL_SIZE\0205\022\030\n"
  "\024GLOBAL_SEARCH_RESULT\0206\022\025\n\021TRANSCODING_F"
  "ILES\0207\022\030\n\024GLOBAL_SEARCH_STATUS\0208\022\017\n\nLIST"
  "_FILES\020\312\001*;\n\013EngineState\022\t\n\005Empty\020\000\022\010\n\004I"
  "dle\020\001\022\013\n\007Playing\020\002\022\n\n\006Paused\020\003*|\n\nRepeat"
  "Mode\022\016\n\nRepeat_Off\020\000\022\020\n\014Repeat_Track\020\001\022\020"
  "\n\014Repeat_Album\020\002\022\023\n\017Repeat_Playlist\020\003\022\023\n"
  "\017Repeat_OneByOne\020\004\022\020\n\014Repeat_Intro\020\005*\\\n\013"
  "ShuffleMode\022\017\n\013Shuffle_Off\020\000\022\017\n\013Shuffle_"
  "All\020\001\022\027\n\023Shuffle_InsideAlbum\020\002\022\022\n\016Shuffl"
  "e_Albums\020\003*k\n\020ReasonDisconnect\022\023\n\017Server"
  "_Shutdown\020\001\022\023\n\017Wrong_Auth_Code\020\002\022\025\n\021Not_"
  "Authenticated\020\003\022\026\n\022Download_Forbidden\020\004*"
  "G\n\014DownloadItem\022\017\n\013CurrentItem\020\001\022\r\n\tItem"
  "Album\020\002\022\r\n\tAPlaylist\020\003\022\010\n\004Urls\020\004*G\n\022Glob"
  "alSearchStatus\022\027\n\023GlobalSearchStarted\020\001\022"
  "\030\n\024GlobalSearchFinished\020\002"
  ;
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_remotecontrolmessages_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_remotecontrolmessages_2eproto = {
  false, false, 7905, descriptor_table_protodef_remotecontrolmessages_2eproto, "remotecontrolmessages.proto", 
  &descriptor_table_remotecontrolmessages_2eproto_once, nullptr, 0, 42,
  schemas, file_default_instances, TableStruct_remotecontrolmessages_2eproto::offsets,
  file_level_metadata_remotecontrolmessages_2eproto, file_level_enum_descriptors_remotecontrolmessages_2eproto, file_level_service_descriptors_remotecontrolmessages_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_remotecontrolmessages_2eproto_getter() {
  return &descriptor_table_remotecontrolmessages_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_remotecontrolmessages_2eproto(&descriptor_table_remotecontrolmessages_2eproto);
namespace cpb {
namespace remote {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SongMetadata_Type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[0];
}
bool SongMetadata_Type_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:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 99:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr SongMetadata_Type SongMetadata::UNKNOWN;
constexpr SongMetadata_Type SongMetadata::ASF;
constexpr SongMetadata_Type SongMetadata::FLAC;
constexpr SongMetadata_Type SongMetadata::MP4;
constexpr SongMetadata_Type SongMetadata::MPC;
constexpr SongMetadata_Type SongMetadata::MPEG;
constexpr SongMetadata_Type SongMetadata::OGGFLAC;
constexpr SongMetadata_Type SongMetadata::OGGSPEEX;
constexpr SongMetadata_Type SongMetadata::OGGVORBIS;
constexpr SongMetadata_Type SongMetadata::AIFF;
constexpr SongMetadata_Type SongMetadata::WAV;
constexpr SongMetadata_Type SongMetadata::TRUEAUDIO;
constexpr SongMetadata_Type SongMetadata::CDDA;
constexpr SongMetadata_Type SongMetadata::OGGOPUS;
constexpr SongMetadata_Type SongMetadata::WAVPACK;
constexpr SongMetadata_Type SongMetadata::SPC;
constexpr SongMetadata_Type SongMetadata::VGM;
constexpr SongMetadata_Type SongMetadata::APE;
constexpr SongMetadata_Type SongMetadata::STREAM;
constexpr SongMetadata_Type SongMetadata::Type_MIN;
constexpr SongMetadata_Type SongMetadata::Type_MAX;
constexpr int SongMetadata::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseListFiles_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[1];
}
bool ResponseListFiles_Error_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseListFiles_Error ResponseListFiles::NONE;
constexpr ResponseListFiles_Error ResponseListFiles::ROOT_DIR_NOT_SET;
constexpr ResponseListFiles_Error ResponseListFiles::DIR_NOT_ACCESSIBLE;
constexpr ResponseListFiles_Error ResponseListFiles::DIR_NOT_EXIST;
constexpr ResponseListFiles_Error ResponseListFiles::UNKNOWN;
constexpr ResponseListFiles_Error ResponseListFiles::Error_MIN;
constexpr ResponseListFiles_Error ResponseListFiles::Error_MAX;
constexpr int ResponseListFiles::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MsgType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[2];
}
bool MsgType_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:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 60:
    case 100:
    case 110:
    case 200:
    case 201:
    case 202:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EngineState_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[3];
}
bool EngineState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RepeatMode_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[4];
}
bool RepeatMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShuffleMode_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[5];
}
bool ShuffleMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReasonDisconnect_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[6];
}
bool ReasonDisconnect_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DownloadItem_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[7];
}
bool DownloadItem_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlobalSearchStatus_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_remotecontrolmessages_2eproto);
  return file_level_enum_descriptors_remotecontrolmessages_2eproto[8];
}
bool GlobalSearchStatus_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

class SongMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<SongMetadata>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_index(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_title(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_album(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_artist(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_albumartist(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_track(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static void set_has_disc(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static void set_has_pretty_year(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_genre(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_playcount(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static void set_has_pretty_length(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_art(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_length(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
  static void set_has_is_local(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static void set_has_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_file_size(HasBits* has_bits) {
    (*has_bits)[0] |= 524288u;
  }
  static void set_has_rating(HasBits* has_bits) {
    (*has_bits)[0] |= 1048576u;
  }
  static void set_has_url(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_art_automatic(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_art_manual(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2097152u;
  }
};

SongMetadata::SongMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.SongMetadata)
}
SongMetadata::SongMetadata(const SongMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  title_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_title()) {
    title_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_title(), 
      GetArena());
  }
  album_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_album()) {
    album_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_album(), 
      GetArena());
  }
  artist_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_artist()) {
    artist_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_artist(), 
      GetArena());
  }
  albumartist_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_albumartist()) {
    albumartist_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_albumartist(), 
      GetArena());
  }
  pretty_year_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_pretty_year()) {
    pretty_year_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pretty_year(), 
      GetArena());
  }
  genre_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_genre()) {
    genre_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_genre(), 
      GetArena());
  }
  pretty_length_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_pretty_length()) {
    pretty_length_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pretty_length(), 
      GetArena());
  }
  art_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_art()) {
    art_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_art(), 
      GetArena());
  }
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_filename()) {
    filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_filename(), 
      GetArena());
  }
  url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_url()) {
    url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_url(), 
      GetArena());
  }
  art_automatic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_art_automatic()) {
    art_automatic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_art_automatic(), 
      GetArena());
  }
  art_manual_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_art_manual()) {
    art_manual_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_art_manual(), 
      GetArena());
  }
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&id_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.SongMetadata)
}

void SongMetadata::SharedCtor() {
title_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
album_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
artist_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
albumartist_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
pretty_year_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
genre_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
pretty_length_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
art_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
art_automatic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
art_manual_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&id_)) + sizeof(type_));
}

SongMetadata::~SongMetadata() {
  // @@protoc_insertion_point(destructor:cpb.remote.SongMetadata)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void SongMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  title_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  album_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  artist_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  albumartist_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pretty_year_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  genre_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pretty_length_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  art_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  art_automatic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  art_manual_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void SongMetadata::ArenaDtor(void* object) {
  SongMetadata* _this = reinterpret_cast< SongMetadata* >(object);
  (void)_this;
}
void SongMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SongMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SongMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.SongMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      title_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      album_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      artist_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000008u) {
      albumartist_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000010u) {
      pretty_year_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000020u) {
      genre_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000040u) {
      pretty_length_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000080u) {
      art_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x00000f00u) {
    if (cached_has_bits & 0x00000100u) {
      filename_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000200u) {
      url_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000400u) {
      art_automatic_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000800u) {
      art_manual_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000f000u) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&disc_) -
        reinterpret_cast<char*>(&id_)) + sizeof(disc_));
  }
  if (cached_has_bits & 0x003f0000u) {
    ::memset(&playcount_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&type_) -
        reinterpret_cast<char*>(&playcount_)) + sizeof(type_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SongMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_index(&has_bits);
          index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string title = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_title();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.title");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string album = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_album();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.album");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string artist = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_artist();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.artist");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string albumartist = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_albumartist();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.albumartist");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 track = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_track(&has_bits);
          track_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 disc = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_disc(&has_bits);
          disc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string pretty_year = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          auto str = _internal_mutable_pretty_year();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.pretty_year");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string genre = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          auto str = _internal_mutable_genre();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.genre");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 playcount = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_playcount(&has_bits);
          playcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string pretty_length = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          auto str = _internal_mutable_pretty_length();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.pretty_length");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes art = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          auto str = _internal_mutable_art();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 length = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
          _Internal::set_has_length(&has_bits);
          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_local = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 120)) {
          _Internal::set_has_is_local(&has_bits);
          is_local_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string filename = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          auto str = _internal_mutable_filename();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.filename");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 file_size = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
          _Internal::set_has_file_size(&has_bits);
          file_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float rating = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 149)) {
          _Internal::set_has_rating(&has_bits);
          rating_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional string url = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          auto str = _internal_mutable_url();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.url");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string art_automatic = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          auto str = _internal_mutable_art_automatic();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.art_automatic");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string art_manual = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          auto str = _internal_mutable_art_manual();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.SongMetadata.art_manual");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.SongMetadata.Type type = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 176)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::SongMetadata_Type_IsValid(val))) {
            _internal_set_type(static_cast<::cpb::remote::SongMetadata_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(22, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SongMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.SongMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  // optional int32 index = 2;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_index(), target);
  }

  // optional string title = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.title");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_title(), target);
  }

  // optional string album = 4;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_album().data(), static_cast<int>(this->_internal_album().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.album");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_album(), target);
  }

  // optional string artist = 5;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_artist().data(), static_cast<int>(this->_internal_artist().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.artist");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_artist(), target);
  }

  // optional string albumartist = 6;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_albumartist().data(), static_cast<int>(this->_internal_albumartist().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.albumartist");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_albumartist(), target);
  }

  // optional int32 track = 7;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_track(), target);
  }

  // optional int32 disc = 8;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_disc(), target);
  }

  // optional string pretty_year = 9;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_pretty_year().data(), static_cast<int>(this->_internal_pretty_year().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.pretty_year");
    target = stream->WriteStringMaybeAliased(
        9, this->_internal_pretty_year(), target);
  }

  // optional string genre = 10;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_genre().data(), static_cast<int>(this->_internal_genre().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.genre");
    target = stream->WriteStringMaybeAliased(
        10, this->_internal_genre(), target);
  }

  // optional int32 playcount = 11;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_playcount(), target);
  }

  // optional string pretty_length = 12;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_pretty_length().data(), static_cast<int>(this->_internal_pretty_length().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.pretty_length");
    target = stream->WriteStringMaybeAliased(
        12, this->_internal_pretty_length(), target);
  }

  // optional bytes art = 13;
  if (cached_has_bits & 0x00000080u) {
    target = stream->WriteBytesMaybeAliased(
        13, this->_internal_art(), target);
  }

  // optional int32 length = 14;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_length(), target);
  }

  // optional bool is_local = 15;
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(15, this->_internal_is_local(), target);
  }

  // optional string filename = 16;
  if (cached_has_bits & 0x00000100u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_filename().data(), static_cast<int>(this->_internal_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.filename");
    target = stream->WriteStringMaybeAliased(
        16, this->_internal_filename(), target);
  }

  // optional int32 file_size = 17;
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(17, this->_internal_file_size(), target);
  }

  // optional float rating = 18;
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(18, this->_internal_rating(), target);
  }

  // optional string url = 19;
  if (cached_has_bits & 0x00000200u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.url");
    target = stream->WriteStringMaybeAliased(
        19, this->_internal_url(), target);
  }

  // optional string art_automatic = 20;
  if (cached_has_bits & 0x00000400u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_art_automatic().data(), static_cast<int>(this->_internal_art_automatic().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.art_automatic");
    target = stream->WriteStringMaybeAliased(
        20, this->_internal_art_automatic(), target);
  }

  // optional string art_manual = 21;
  if (cached_has_bits & 0x00000800u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_art_manual().data(), static_cast<int>(this->_internal_art_manual().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.SongMetadata.art_manual");
    target = stream->WriteStringMaybeAliased(
        21, this->_internal_art_manual(), target);
  }

  // optional .cpb.remote.SongMetadata.Type type = 22;
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      22, this->_internal_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.SongMetadata)
  return target;
}

size_t SongMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.SongMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string title = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_title());
    }

    // optional string album = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_album());
    }

    // optional string artist = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_artist());
    }

    // optional string albumartist = 6;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_albumartist());
    }

    // optional string pretty_year = 9;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_pretty_year());
    }

    // optional string genre = 10;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_genre());
    }

    // optional string pretty_length = 12;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_pretty_length());
    }

    // optional bytes art = 13;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_art());
    }

  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional string filename = 16;
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_filename());
    }

    // optional string url = 19;
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_url());
    }

    // optional string art_automatic = 20;
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_art_automatic());
    }

    // optional string art_manual = 21;
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_art_manual());
    }

    // optional int32 id = 1;
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_id());
    }

    // optional int32 index = 2;
    if (cached_has_bits & 0x00002000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_index());
    }

    // optional int32 track = 7;
    if (cached_has_bits & 0x00004000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_track());
    }

    // optional int32 disc = 8;
    if (cached_has_bits & 0x00008000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_disc());
    }

  }
  if (cached_has_bits & 0x003f0000u) {
    // optional int32 playcount = 11;
    if (cached_has_bits & 0x00010000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playcount());
    }

    // optional int32 length = 14;
    if (cached_has_bits & 0x00020000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_length());
    }

    // optional bool is_local = 15;
    if (cached_has_bits & 0x00040000u) {
      total_size += 1 + 1;
    }

    // optional int32 file_size = 17;
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_file_size());
    }

    // optional float rating = 18;
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 + 4;
    }

    // optional .cpb.remote.SongMetadata.Type type = 22;
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SongMetadata::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.SongMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  const SongMetadata* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SongMetadata>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.SongMetadata)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.SongMetadata)
    MergeFrom(*source);
  }
}

void SongMetadata::MergeFrom(const SongMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.SongMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_title(from._internal_title());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_album(from._internal_album());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_artist(from._internal_artist());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_set_albumartist(from._internal_albumartist());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_set_pretty_year(from._internal_pretty_year());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_set_genre(from._internal_genre());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_set_pretty_length(from._internal_pretty_length());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_set_art(from._internal_art());
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_set_filename(from._internal_filename());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_set_url(from._internal_url());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_set_art_automatic(from._internal_art_automatic());
    }
    if (cached_has_bits & 0x00000800u) {
      _internal_set_art_manual(from._internal_art_manual());
    }
    if (cached_has_bits & 0x00001000u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00002000u) {
      index_ = from.index_;
    }
    if (cached_has_bits & 0x00004000u) {
      track_ = from.track_;
    }
    if (cached_has_bits & 0x00008000u) {
      disc_ = from.disc_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x003f0000u) {
    if (cached_has_bits & 0x00010000u) {
      playcount_ = from.playcount_;
    }
    if (cached_has_bits & 0x00020000u) {
      length_ = from.length_;
    }
    if (cached_has_bits & 0x00040000u) {
      is_local_ = from.is_local_;
    }
    if (cached_has_bits & 0x00080000u) {
      file_size_ = from.file_size_;
    }
    if (cached_has_bits & 0x00100000u) {
      rating_ = from.rating_;
    }
    if (cached_has_bits & 0x00200000u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SongMetadata::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.SongMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SongMetadata::CopyFrom(const SongMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.SongMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SongMetadata::IsInitialized() const {
  return true;
}

void SongMetadata::InternalSwap(SongMetadata* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  title_.Swap(&other->title_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  album_.Swap(&other->album_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  artist_.Swap(&other->artist_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  albumartist_.Swap(&other->albumartist_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  pretty_year_.Swap(&other->pretty_year_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  genre_.Swap(&other->genre_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  pretty_length_.Swap(&other->pretty_length_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  art_.Swap(&other->art_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  filename_.Swap(&other->filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  art_automatic_.Swap(&other->art_automatic_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  art_manual_.Swap(&other->art_manual_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SongMetadata, type_)
      + sizeof(SongMetadata::type_)
      - PROTOBUF_FIELD_OFFSET(SongMetadata, id_)>(
          reinterpret_cast<char*>(&id_),
          reinterpret_cast<char*>(&other->id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata SongMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[0]);
}

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

class Playlist::_Internal {
 public:
  using HasBits = decltype(std::declval<Playlist>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_item_count(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_active(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_closed(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_favorite(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

Playlist::Playlist(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Playlist)
}
Playlist::Playlist(const Playlist& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArena());
  }
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&favorite_) -
    reinterpret_cast<char*>(&id_)) + sizeof(favorite_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Playlist)
}

void Playlist::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&favorite_) -
    reinterpret_cast<char*>(&id_)) + sizeof(favorite_));
}

Playlist::~Playlist() {
  // @@protoc_insertion_point(destructor:cpb.remote.Playlist)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Playlist::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Playlist::ArenaDtor(void* object) {
  Playlist* _this = reinterpret_cast< Playlist* >(object);
  (void)_this;
}
void Playlist::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Playlist::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Playlist::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Playlist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&favorite_) -
        reinterpret_cast<char*>(&id_)) + sizeof(favorite_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Playlist::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Playlist.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 item_count = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_item_count(&has_bits);
          item_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool active = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_active(&has_bits);
          active_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool closed = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_closed(&has_bits);
          closed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool favorite = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_favorite(&has_bits);
          favorite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Playlist::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Playlist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  // optional string name = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Playlist.name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_name(), target);
  }

  // optional int32 item_count = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_item_count(), target);
  }

  // optional bool active = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_active(), target);
  }

  // optional bool closed = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_closed(), target);
  }

  // optional bool favorite = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_favorite(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Playlist)
  return target;
}

size_t Playlist::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Playlist)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional string name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional int32 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_id());
    }

    // optional int32 item_count = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_item_count());
    }

    // optional bool active = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool closed = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool favorite = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Playlist::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Playlist)
  GOOGLE_DCHECK_NE(&from, this);
  const Playlist* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Playlist>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Playlist)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Playlist)
    MergeFrom(*source);
  }
}

void Playlist::MergeFrom(const Playlist& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Playlist)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      item_count_ = from.item_count_;
    }
    if (cached_has_bits & 0x00000008u) {
      active_ = from.active_;
    }
    if (cached_has_bits & 0x00000010u) {
      closed_ = from.closed_;
    }
    if (cached_has_bits & 0x00000020u) {
      favorite_ = from.favorite_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Playlist::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Playlist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Playlist::CopyFrom(const Playlist& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Playlist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Playlist::IsInitialized() const {
  return true;
}

void Playlist::InternalSwap(Playlist* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Playlist, favorite_)
      + sizeof(Playlist::favorite_)
      - PROTOBUF_FIELD_OFFSET(Playlist, id_)>(
          reinterpret_cast<char*>(&id_),
          reinterpret_cast<char*>(&other->id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Playlist::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[1]);
}

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

class RequestPlaylists::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestPlaylists>()._has_bits_);
  static void set_has_include_closed(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestPlaylists::RequestPlaylists(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestPlaylists)
}
RequestPlaylists::RequestPlaylists(const RequestPlaylists& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  include_closed_ = from.include_closed_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestPlaylists)
}

void RequestPlaylists::SharedCtor() {
include_closed_ = false;
}

RequestPlaylists::~RequestPlaylists() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestPlaylists)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestPlaylists::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestPlaylists::ArenaDtor(void* object) {
  RequestPlaylists* _this = reinterpret_cast< RequestPlaylists* >(object);
  (void)_this;
}
void RequestPlaylists::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestPlaylists::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestPlaylists::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestPlaylists)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  include_closed_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestPlaylists::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bool include_closed = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_include_closed(&has_bits);
          include_closed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestPlaylists::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestPlaylists)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool include_closed = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_include_closed(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestPlaylists)
  return target;
}

size_t RequestPlaylists::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestPlaylists)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool include_closed = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestPlaylists::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestPlaylists)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestPlaylists* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestPlaylists>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestPlaylists)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestPlaylists)
    MergeFrom(*source);
  }
}

void RequestPlaylists::MergeFrom(const RequestPlaylists& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestPlaylists)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_include_closed()) {
    _internal_set_include_closed(from._internal_include_closed());
  }
}

void RequestPlaylists::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestPlaylists)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestPlaylists::CopyFrom(const RequestPlaylists& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestPlaylists)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestPlaylists::IsInitialized() const {
  return true;
}

void RequestPlaylists::InternalSwap(RequestPlaylists* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(include_closed_, other->include_closed_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestPlaylists::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[2]);
}

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

class RequestPlaylistSongs::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestPlaylistSongs>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestPlaylistSongs::RequestPlaylistSongs(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestPlaylistSongs)
}
RequestPlaylistSongs::RequestPlaylistSongs(const RequestPlaylistSongs& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestPlaylistSongs)
}

void RequestPlaylistSongs::SharedCtor() {
id_ = 0;
}

RequestPlaylistSongs::~RequestPlaylistSongs() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestPlaylistSongs)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestPlaylistSongs::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestPlaylistSongs::ArenaDtor(void* object) {
  RequestPlaylistSongs* _this = reinterpret_cast< RequestPlaylistSongs* >(object);
  (void)_this;
}
void RequestPlaylistSongs::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestPlaylistSongs::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestPlaylistSongs::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestPlaylistSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestPlaylistSongs::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestPlaylistSongs::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestPlaylistSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestPlaylistSongs)
  return target;
}

size_t RequestPlaylistSongs::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestPlaylistSongs)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestPlaylistSongs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestPlaylistSongs)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestPlaylistSongs* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestPlaylistSongs>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestPlaylistSongs)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestPlaylistSongs)
    MergeFrom(*source);
  }
}

void RequestPlaylistSongs::MergeFrom(const RequestPlaylistSongs& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestPlaylistSongs)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_id()) {
    _internal_set_id(from._internal_id());
  }
}

void RequestPlaylistSongs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestPlaylistSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestPlaylistSongs::CopyFrom(const RequestPlaylistSongs& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestPlaylistSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestPlaylistSongs::IsInitialized() const {
  return true;
}

void RequestPlaylistSongs::InternalSwap(RequestPlaylistSongs* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(id_, other->id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestPlaylistSongs::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[3]);
}

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

class RequestChangeSong::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestChangeSong>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_song_index(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

RequestChangeSong::RequestChangeSong(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestChangeSong)
}
RequestChangeSong::RequestChangeSong(const RequestChangeSong& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&playlist_id_, &from.playlist_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&song_index_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(song_index_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestChangeSong)
}

void RequestChangeSong::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&playlist_id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&song_index_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(song_index_));
}

RequestChangeSong::~RequestChangeSong() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestChangeSong)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestChangeSong::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestChangeSong::ArenaDtor(void* object) {
  RequestChangeSong* _this = reinterpret_cast< RequestChangeSong* >(object);
  (void)_this;
}
void RequestChangeSong::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestChangeSong::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestChangeSong::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestChangeSong)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&playlist_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&song_index_) -
        reinterpret_cast<char*>(&playlist_id_)) + sizeof(song_index_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestChangeSong::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 song_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_song_index(&has_bits);
          song_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestChangeSong::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestChangeSong)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  // optional int32 song_index = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_song_index(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestChangeSong)
  return target;
}

size_t RequestChangeSong::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestChangeSong)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 playlist_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playlist_id());
    }

    // optional int32 song_index = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_song_index());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestChangeSong::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestChangeSong)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestChangeSong* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestChangeSong>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestChangeSong)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestChangeSong)
    MergeFrom(*source);
  }
}

void RequestChangeSong::MergeFrom(const RequestChangeSong& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestChangeSong)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      playlist_id_ = from.playlist_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      song_index_ = from.song_index_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestChangeSong::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestChangeSong)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestChangeSong::CopyFrom(const RequestChangeSong& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestChangeSong)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestChangeSong::IsInitialized() const {
  return true;
}

void RequestChangeSong::InternalSwap(RequestChangeSong* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestChangeSong, song_index_)
      + sizeof(RequestChangeSong::song_index_)
      - PROTOBUF_FIELD_OFFSET(RequestChangeSong, playlist_id_)>(
          reinterpret_cast<char*>(&playlist_id_),
          reinterpret_cast<char*>(&other->playlist_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestChangeSong::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[4]);
}

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

class RequestSetVolume::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestSetVolume>()._has_bits_);
  static void set_has_volume(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestSetVolume::RequestSetVolume(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestSetVolume)
}
RequestSetVolume::RequestSetVolume(const RequestSetVolume& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  volume_ = from.volume_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestSetVolume)
}

void RequestSetVolume::SharedCtor() {
volume_ = 0;
}

RequestSetVolume::~RequestSetVolume() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestSetVolume)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestSetVolume::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestSetVolume::ArenaDtor(void* object) {
  RequestSetVolume* _this = reinterpret_cast< RequestSetVolume* >(object);
  (void)_this;
}
void RequestSetVolume::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestSetVolume::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestSetVolume::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestSetVolume)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  volume_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestSetVolume::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 volume = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_volume(&has_bits);
          volume_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestSetVolume::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestSetVolume)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 volume = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_volume(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestSetVolume)
  return target;
}

size_t RequestSetVolume::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestSetVolume)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 volume = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_volume());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestSetVolume::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestSetVolume)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestSetVolume* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestSetVolume>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestSetVolume)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestSetVolume)
    MergeFrom(*source);
  }
}

void RequestSetVolume::MergeFrom(const RequestSetVolume& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestSetVolume)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_volume()) {
    _internal_set_volume(from._internal_volume());
  }
}

void RequestSetVolume::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestSetVolume)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestSetVolume::CopyFrom(const RequestSetVolume& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestSetVolume)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestSetVolume::IsInitialized() const {
  return true;
}

void RequestSetVolume::InternalSwap(RequestSetVolume* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(volume_, other->volume_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestSetVolume::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[5]);
}

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

class Repeat::_Internal {
 public:
  using HasBits = decltype(std::declval<Repeat>()._has_bits_);
  static void set_has_repeat_mode(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Repeat::Repeat(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Repeat)
}
Repeat::Repeat(const Repeat& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  repeat_mode_ = from.repeat_mode_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Repeat)
}

void Repeat::SharedCtor() {
repeat_mode_ = 0;
}

Repeat::~Repeat() {
  // @@protoc_insertion_point(destructor:cpb.remote.Repeat)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Repeat::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Repeat::ArenaDtor(void* object) {
  Repeat* _this = reinterpret_cast< Repeat* >(object);
  (void)_this;
}
void Repeat::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Repeat::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Repeat::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Repeat)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  repeat_mode_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Repeat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.RepeatMode repeat_mode = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::RepeatMode_IsValid(val))) {
            _internal_set_repeat_mode(static_cast<::cpb::remote::RepeatMode>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Repeat::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Repeat)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.RepeatMode repeat_mode = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_repeat_mode(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Repeat)
  return target;
}

size_t Repeat::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Repeat)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .cpb.remote.RepeatMode repeat_mode = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_repeat_mode());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Repeat::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Repeat)
  GOOGLE_DCHECK_NE(&from, this);
  const Repeat* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Repeat>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Repeat)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Repeat)
    MergeFrom(*source);
  }
}

void Repeat::MergeFrom(const Repeat& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Repeat)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_repeat_mode()) {
    _internal_set_repeat_mode(from._internal_repeat_mode());
  }
}

void Repeat::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Repeat)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Repeat::CopyFrom(const Repeat& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Repeat)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Repeat::IsInitialized() const {
  return true;
}

void Repeat::InternalSwap(Repeat* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(repeat_mode_, other->repeat_mode_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Repeat::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[6]);
}

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

class Shuffle::_Internal {
 public:
  using HasBits = decltype(std::declval<Shuffle>()._has_bits_);
  static void set_has_shuffle_mode(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Shuffle::Shuffle(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Shuffle)
}
Shuffle::Shuffle(const Shuffle& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  shuffle_mode_ = from.shuffle_mode_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Shuffle)
}

void Shuffle::SharedCtor() {
shuffle_mode_ = 0;
}

Shuffle::~Shuffle() {
  // @@protoc_insertion_point(destructor:cpb.remote.Shuffle)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Shuffle::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Shuffle::ArenaDtor(void* object) {
  Shuffle* _this = reinterpret_cast< Shuffle* >(object);
  (void)_this;
}
void Shuffle::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Shuffle::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Shuffle::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Shuffle)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  shuffle_mode_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Shuffle::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.ShuffleMode shuffle_mode = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::ShuffleMode_IsValid(val))) {
            _internal_set_shuffle_mode(static_cast<::cpb::remote::ShuffleMode>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Shuffle::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Shuffle)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.ShuffleMode shuffle_mode = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_shuffle_mode(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Shuffle)
  return target;
}

size_t Shuffle::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Shuffle)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .cpb.remote.ShuffleMode shuffle_mode = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_shuffle_mode());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Shuffle::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Shuffle)
  GOOGLE_DCHECK_NE(&from, this);
  const Shuffle* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Shuffle>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Shuffle)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Shuffle)
    MergeFrom(*source);
  }
}

void Shuffle::MergeFrom(const Shuffle& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Shuffle)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_shuffle_mode()) {
    _internal_set_shuffle_mode(from._internal_shuffle_mode());
  }
}

void Shuffle::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Shuffle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Shuffle::CopyFrom(const Shuffle& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Shuffle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Shuffle::IsInitialized() const {
  return true;
}

void Shuffle::InternalSwap(Shuffle* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(shuffle_mode_, other->shuffle_mode_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Shuffle::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[7]);
}

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

class ResponseClementineInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseClementineInfo>()._has_bits_);
  static void set_has_version(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_allow_downloads(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

ResponseClementineInfo::ResponseClementineInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  files_music_extensions_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseClementineInfo)
}
ResponseClementineInfo::ResponseClementineInfo(const ResponseClementineInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      files_music_extensions_(from.files_music_extensions_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_version()) {
    version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_version(), 
      GetArena());
  }
  ::memcpy(&state_, &from.state_,
    static_cast<size_t>(reinterpret_cast<char*>(&allow_downloads_) -
    reinterpret_cast<char*>(&state_)) + sizeof(allow_downloads_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseClementineInfo)
}

void ResponseClementineInfo::SharedCtor() {
version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&state_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&allow_downloads_) -
    reinterpret_cast<char*>(&state_)) + sizeof(allow_downloads_));
}

ResponseClementineInfo::~ResponseClementineInfo() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseClementineInfo)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseClementineInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ResponseClementineInfo::ArenaDtor(void* object) {
  ResponseClementineInfo* _this = reinterpret_cast< ResponseClementineInfo* >(object);
  (void)_this;
}
void ResponseClementineInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseClementineInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseClementineInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseClementineInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  files_music_extensions_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    version_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&state_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&allow_downloads_) -
        reinterpret_cast<char*>(&state_)) + sizeof(allow_downloads_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseClementineInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseClementineInfo.version");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.EngineState state = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::EngineState_IsValid(val))) {
            _internal_set_state(static_cast<::cpb::remote::EngineState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bool allow_downloads = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_allow_downloads(&has_bits);
          allow_downloads_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string files_music_extensions = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_files_music_extensions();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseClementineInfo.files_music_extensions");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseClementineInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseClementineInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string version = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseClementineInfo.version");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_version(), target);
  }

  // optional .cpb.remote.EngineState state = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_state(), target);
  }

  // optional bool allow_downloads = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_allow_downloads(), target);
  }

  // repeated string files_music_extensions = 4;
  for (int i = 0, n = this->_internal_files_music_extensions_size(); i < n; i++) {
    const auto& s = this->_internal_files_music_extensions(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseClementineInfo.files_music_extensions");
    target = stream->WriteString(4, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseClementineInfo)
  return target;
}

size_t ResponseClementineInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseClementineInfo)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string files_music_extensions = 4;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(files_music_extensions_.size());
  for (int i = 0, n = files_music_extensions_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      files_music_extensions_.Get(i));
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string version = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_version());
    }

    // optional .cpb.remote.EngineState state = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state());
    }

    // optional bool allow_downloads = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseClementineInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseClementineInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseClementineInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseClementineInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseClementineInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseClementineInfo)
    MergeFrom(*source);
  }
}

void ResponseClementineInfo::MergeFrom(const ResponseClementineInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseClementineInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  files_music_extensions_.MergeFrom(from.files_music_extensions_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_version(from._internal_version());
    }
    if (cached_has_bits & 0x00000002u) {
      state_ = from.state_;
    }
    if (cached_has_bits & 0x00000004u) {
      allow_downloads_ = from.allow_downloads_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseClementineInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseClementineInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseClementineInfo::CopyFrom(const ResponseClementineInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseClementineInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseClementineInfo::IsInitialized() const {
  return true;
}

void ResponseClementineInfo::InternalSwap(ResponseClementineInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  files_music_extensions_.InternalSwap(&other->files_music_extensions_);
  version_.Swap(&other->version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseClementineInfo, allow_downloads_)
      + sizeof(ResponseClementineInfo::allow_downloads_)
      - PROTOBUF_FIELD_OFFSET(ResponseClementineInfo, state_)>(
          reinterpret_cast<char*>(&state_),
          reinterpret_cast<char*>(&other->state_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseClementineInfo::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[8]);
}

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

class ResponseCurrentMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseCurrentMetadata>()._has_bits_);
  static const ::cpb::remote::SongMetadata& song_metadata(const ResponseCurrentMetadata* msg);
  static void set_has_song_metadata(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::cpb::remote::SongMetadata&
ResponseCurrentMetadata::_Internal::song_metadata(const ResponseCurrentMetadata* msg) {
  return *msg->song_metadata_;
}
ResponseCurrentMetadata::ResponseCurrentMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseCurrentMetadata)
}
ResponseCurrentMetadata::ResponseCurrentMetadata(const ResponseCurrentMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_song_metadata()) {
    song_metadata_ = new ::cpb::remote::SongMetadata(*from.song_metadata_);
  } else {
    song_metadata_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseCurrentMetadata)
}

void ResponseCurrentMetadata::SharedCtor() {
song_metadata_ = nullptr;
}

ResponseCurrentMetadata::~ResponseCurrentMetadata() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseCurrentMetadata)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseCurrentMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete song_metadata_;
}

void ResponseCurrentMetadata::ArenaDtor(void* object) {
  ResponseCurrentMetadata* _this = reinterpret_cast< ResponseCurrentMetadata* >(object);
  (void)_this;
}
void ResponseCurrentMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseCurrentMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseCurrentMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseCurrentMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(song_metadata_ != nullptr);
    song_metadata_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseCurrentMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.SongMetadata song_metadata = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_song_metadata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseCurrentMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseCurrentMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.SongMetadata song_metadata = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::song_metadata(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseCurrentMetadata)
  return target;
}

size_t ResponseCurrentMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseCurrentMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .cpb.remote.SongMetadata song_metadata = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *song_metadata_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseCurrentMetadata::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseCurrentMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseCurrentMetadata* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseCurrentMetadata>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseCurrentMetadata)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseCurrentMetadata)
    MergeFrom(*source);
  }
}

void ResponseCurrentMetadata::MergeFrom(const ResponseCurrentMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseCurrentMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_song_metadata()) {
    _internal_mutable_song_metadata()->::cpb::remote::SongMetadata::MergeFrom(from._internal_song_metadata());
  }
}

void ResponseCurrentMetadata::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseCurrentMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseCurrentMetadata::CopyFrom(const ResponseCurrentMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseCurrentMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseCurrentMetadata::IsInitialized() const {
  return true;
}

void ResponseCurrentMetadata::InternalSwap(ResponseCurrentMetadata* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(song_metadata_, other->song_metadata_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseCurrentMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[9]);
}

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

class ResponsePlaylists::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponsePlaylists>()._has_bits_);
  static void set_has_include_closed(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponsePlaylists::ResponsePlaylists(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  playlist_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponsePlaylists)
}
ResponsePlaylists::ResponsePlaylists(const ResponsePlaylists& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      playlist_(from.playlist_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  include_closed_ = from.include_closed_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponsePlaylists)
}

void ResponsePlaylists::SharedCtor() {
include_closed_ = false;
}

ResponsePlaylists::~ResponsePlaylists() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponsePlaylists)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponsePlaylists::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponsePlaylists::ArenaDtor(void* object) {
  ResponsePlaylists* _this = reinterpret_cast< ResponsePlaylists* >(object);
  (void)_this;
}
void ResponsePlaylists::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponsePlaylists::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponsePlaylists::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponsePlaylists)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  playlist_.Clear();
  include_closed_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponsePlaylists::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .cpb.remote.Playlist playlist = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_playlist(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bool include_closed = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_include_closed(&has_bits);
          include_closed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponsePlaylists::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponsePlaylists)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .cpb.remote.Playlist playlist = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_playlist_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_playlist(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool include_closed = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_include_closed(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponsePlaylists)
  return target;
}

size_t ResponsePlaylists::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponsePlaylists)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.Playlist playlist = 1;
  total_size += 1UL * this->_internal_playlist_size();
  for (const auto& msg : this->playlist_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional bool include_closed = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponsePlaylists::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponsePlaylists)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponsePlaylists* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponsePlaylists>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponsePlaylists)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponsePlaylists)
    MergeFrom(*source);
  }
}

void ResponsePlaylists::MergeFrom(const ResponsePlaylists& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponsePlaylists)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  playlist_.MergeFrom(from.playlist_);
  if (from._internal_has_include_closed()) {
    _internal_set_include_closed(from._internal_include_closed());
  }
}

void ResponsePlaylists::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponsePlaylists)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponsePlaylists::CopyFrom(const ResponsePlaylists& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponsePlaylists)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponsePlaylists::IsInitialized() const {
  return true;
}

void ResponsePlaylists::InternalSwap(ResponsePlaylists* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  playlist_.InternalSwap(&other->playlist_);
  swap(include_closed_, other->include_closed_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponsePlaylists::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[10]);
}

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

class ResponsePlaylistSongs::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponsePlaylistSongs>()._has_bits_);
  static const ::cpb::remote::Playlist& requested_playlist(const ResponsePlaylistSongs* msg);
  static void set_has_requested_playlist(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::cpb::remote::Playlist&
ResponsePlaylistSongs::_Internal::requested_playlist(const ResponsePlaylistSongs* msg) {
  return *msg->requested_playlist_;
}
ResponsePlaylistSongs::ResponsePlaylistSongs(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  songs_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponsePlaylistSongs)
}
ResponsePlaylistSongs::ResponsePlaylistSongs(const ResponsePlaylistSongs& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      songs_(from.songs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_requested_playlist()) {
    requested_playlist_ = new ::cpb::remote::Playlist(*from.requested_playlist_);
  } else {
    requested_playlist_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponsePlaylistSongs)
}

void ResponsePlaylistSongs::SharedCtor() {
requested_playlist_ = nullptr;
}

ResponsePlaylistSongs::~ResponsePlaylistSongs() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponsePlaylistSongs)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponsePlaylistSongs::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete requested_playlist_;
}

void ResponsePlaylistSongs::ArenaDtor(void* object) {
  ResponsePlaylistSongs* _this = reinterpret_cast< ResponsePlaylistSongs* >(object);
  (void)_this;
}
void ResponsePlaylistSongs::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponsePlaylistSongs::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponsePlaylistSongs::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponsePlaylistSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  songs_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(requested_playlist_ != nullptr);
    requested_playlist_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponsePlaylistSongs::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.Playlist requested_playlist = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_requested_playlist(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .cpb.remote.SongMetadata songs = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_songs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponsePlaylistSongs::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponsePlaylistSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.Playlist requested_playlist = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::requested_playlist(this), target, stream);
  }

  // repeated .cpb.remote.SongMetadata songs = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_songs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_songs(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponsePlaylistSongs)
  return target;
}

size_t ResponsePlaylistSongs::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponsePlaylistSongs)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.SongMetadata songs = 2;
  total_size += 1UL * this->_internal_songs_size();
  for (const auto& msg : this->songs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional .cpb.remote.Playlist requested_playlist = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *requested_playlist_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponsePlaylistSongs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponsePlaylistSongs)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponsePlaylistSongs* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponsePlaylistSongs>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponsePlaylistSongs)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponsePlaylistSongs)
    MergeFrom(*source);
  }
}

void ResponsePlaylistSongs::MergeFrom(const ResponsePlaylistSongs& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponsePlaylistSongs)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  songs_.MergeFrom(from.songs_);
  if (from._internal_has_requested_playlist()) {
    _internal_mutable_requested_playlist()->::cpb::remote::Playlist::MergeFrom(from._internal_requested_playlist());
  }
}

void ResponsePlaylistSongs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponsePlaylistSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponsePlaylistSongs::CopyFrom(const ResponsePlaylistSongs& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponsePlaylistSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponsePlaylistSongs::IsInitialized() const {
  return true;
}

void ResponsePlaylistSongs::InternalSwap(ResponsePlaylistSongs* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  songs_.InternalSwap(&other->songs_);
  swap(requested_playlist_, other->requested_playlist_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponsePlaylistSongs::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[11]);
}

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

class ResponseEngineStateChanged::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseEngineStateChanged>()._has_bits_);
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseEngineStateChanged::ResponseEngineStateChanged(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseEngineStateChanged)
}
ResponseEngineStateChanged::ResponseEngineStateChanged(const ResponseEngineStateChanged& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  state_ = from.state_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseEngineStateChanged)
}

void ResponseEngineStateChanged::SharedCtor() {
state_ = 0;
}

ResponseEngineStateChanged::~ResponseEngineStateChanged() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseEngineStateChanged)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseEngineStateChanged::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseEngineStateChanged::ArenaDtor(void* object) {
  ResponseEngineStateChanged* _this = reinterpret_cast< ResponseEngineStateChanged* >(object);
  (void)_this;
}
void ResponseEngineStateChanged::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseEngineStateChanged::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseEngineStateChanged::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseEngineStateChanged)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  state_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseEngineStateChanged::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.EngineState state = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::EngineState_IsValid(val))) {
            _internal_set_state(static_cast<::cpb::remote::EngineState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseEngineStateChanged::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseEngineStateChanged)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.EngineState state = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_state(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseEngineStateChanged)
  return target;
}

size_t ResponseEngineStateChanged::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseEngineStateChanged)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .cpb.remote.EngineState state = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseEngineStateChanged::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseEngineStateChanged)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseEngineStateChanged* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseEngineStateChanged>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseEngineStateChanged)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseEngineStateChanged)
    MergeFrom(*source);
  }
}

void ResponseEngineStateChanged::MergeFrom(const ResponseEngineStateChanged& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseEngineStateChanged)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_state()) {
    _internal_set_state(from._internal_state());
  }
}

void ResponseEngineStateChanged::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseEngineStateChanged)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseEngineStateChanged::CopyFrom(const ResponseEngineStateChanged& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseEngineStateChanged)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseEngineStateChanged::IsInitialized() const {
  return true;
}

void ResponseEngineStateChanged::InternalSwap(ResponseEngineStateChanged* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(state_, other->state_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseEngineStateChanged::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[12]);
}

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

class ResponseUpdateTrackPosition::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseUpdateTrackPosition>()._has_bits_);
  static void set_has_position(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseUpdateTrackPosition::ResponseUpdateTrackPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseUpdateTrackPosition)
}
ResponseUpdateTrackPosition::ResponseUpdateTrackPosition(const ResponseUpdateTrackPosition& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  position_ = from.position_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseUpdateTrackPosition)
}

void ResponseUpdateTrackPosition::SharedCtor() {
position_ = 0;
}

ResponseUpdateTrackPosition::~ResponseUpdateTrackPosition() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseUpdateTrackPosition)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseUpdateTrackPosition::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseUpdateTrackPosition::ArenaDtor(void* object) {
  ResponseUpdateTrackPosition* _this = reinterpret_cast< ResponseUpdateTrackPosition* >(object);
  (void)_this;
}
void ResponseUpdateTrackPosition::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseUpdateTrackPosition::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseUpdateTrackPosition::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseUpdateTrackPosition)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  position_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseUpdateTrackPosition::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 position = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_position(&has_bits);
          position_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseUpdateTrackPosition::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseUpdateTrackPosition)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 position = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_position(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseUpdateTrackPosition)
  return target;
}

size_t ResponseUpdateTrackPosition::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseUpdateTrackPosition)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 position = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_position());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseUpdateTrackPosition::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseUpdateTrackPosition)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseUpdateTrackPosition* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseUpdateTrackPosition>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseUpdateTrackPosition)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseUpdateTrackPosition)
    MergeFrom(*source);
  }
}

void ResponseUpdateTrackPosition::MergeFrom(const ResponseUpdateTrackPosition& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseUpdateTrackPosition)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_position()) {
    _internal_set_position(from._internal_position());
  }
}

void ResponseUpdateTrackPosition::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseUpdateTrackPosition)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseUpdateTrackPosition::CopyFrom(const ResponseUpdateTrackPosition& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseUpdateTrackPosition)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseUpdateTrackPosition::IsInitialized() const {
  return true;
}

void ResponseUpdateTrackPosition::InternalSwap(ResponseUpdateTrackPosition* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(position_, other->position_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseUpdateTrackPosition::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[13]);
}

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

class RequestConnect::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestConnect>()._has_bits_);
  static void set_has_auth_code(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_send_playlist_songs(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_downloader(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

RequestConnect::RequestConnect(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestConnect)
}
RequestConnect::RequestConnect(const RequestConnect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&auth_code_, &from.auth_code_,
    static_cast<size_t>(reinterpret_cast<char*>(&downloader_) -
    reinterpret_cast<char*>(&auth_code_)) + sizeof(downloader_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestConnect)
}

void RequestConnect::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&auth_code_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&downloader_) -
    reinterpret_cast<char*>(&auth_code_)) + sizeof(downloader_));
}

RequestConnect::~RequestConnect() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestConnect)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestConnect::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestConnect::ArenaDtor(void* object) {
  RequestConnect* _this = reinterpret_cast< RequestConnect* >(object);
  (void)_this;
}
void RequestConnect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestConnect::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestConnect::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestConnect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&auth_code_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&downloader_) -
        reinterpret_cast<char*>(&auth_code_)) + sizeof(downloader_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestConnect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 auth_code = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_auth_code(&has_bits);
          auth_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool send_playlist_songs = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_send_playlist_songs(&has_bits);
          send_playlist_songs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool downloader = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_downloader(&has_bits);
          downloader_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestConnect::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestConnect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 auth_code = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_auth_code(), target);
  }

  // optional bool send_playlist_songs = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_send_playlist_songs(), target);
  }

  // optional bool downloader = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_downloader(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestConnect)
  return target;
}

size_t RequestConnect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestConnect)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int32 auth_code = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_auth_code());
    }

    // optional bool send_playlist_songs = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional bool downloader = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestConnect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestConnect)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestConnect* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestConnect>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestConnect)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestConnect)
    MergeFrom(*source);
  }
}

void RequestConnect::MergeFrom(const RequestConnect& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestConnect)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      auth_code_ = from.auth_code_;
    }
    if (cached_has_bits & 0x00000002u) {
      send_playlist_songs_ = from.send_playlist_songs_;
    }
    if (cached_has_bits & 0x00000004u) {
      downloader_ = from.downloader_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestConnect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestConnect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestConnect::CopyFrom(const RequestConnect& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestConnect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestConnect::IsInitialized() const {
  return true;
}

void RequestConnect::InternalSwap(RequestConnect* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestConnect, downloader_)
      + sizeof(RequestConnect::downloader_)
      - PROTOBUF_FIELD_OFFSET(RequestConnect, auth_code_)>(
          reinterpret_cast<char*>(&auth_code_),
          reinterpret_cast<char*>(&other->auth_code_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestConnect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[14]);
}

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

class ResponseDisconnect::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseDisconnect>()._has_bits_);
  static void set_has_reason_disconnect(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseDisconnect::ResponseDisconnect(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseDisconnect)
}
ResponseDisconnect::ResponseDisconnect(const ResponseDisconnect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  reason_disconnect_ = from.reason_disconnect_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseDisconnect)
}

void ResponseDisconnect::SharedCtor() {
reason_disconnect_ = 1;
}

ResponseDisconnect::~ResponseDisconnect() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseDisconnect)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseDisconnect::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseDisconnect::ArenaDtor(void* object) {
  ResponseDisconnect* _this = reinterpret_cast< ResponseDisconnect* >(object);
  (void)_this;
}
void ResponseDisconnect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseDisconnect::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseDisconnect::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseDisconnect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  reason_disconnect_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseDisconnect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.ReasonDisconnect reason_disconnect = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::ReasonDisconnect_IsValid(val))) {
            _internal_set_reason_disconnect(static_cast<::cpb::remote::ReasonDisconnect>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseDisconnect::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseDisconnect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.ReasonDisconnect reason_disconnect = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_reason_disconnect(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseDisconnect)
  return target;
}

size_t ResponseDisconnect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseDisconnect)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .cpb.remote.ReasonDisconnect reason_disconnect = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_reason_disconnect());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseDisconnect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseDisconnect)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseDisconnect* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseDisconnect>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseDisconnect)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseDisconnect)
    MergeFrom(*source);
  }
}

void ResponseDisconnect::MergeFrom(const ResponseDisconnect& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseDisconnect)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_reason_disconnect()) {
    _internal_set_reason_disconnect(from._internal_reason_disconnect());
  }
}

void ResponseDisconnect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseDisconnect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseDisconnect::CopyFrom(const ResponseDisconnect& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseDisconnect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseDisconnect::IsInitialized() const {
  return true;
}

void ResponseDisconnect::InternalSwap(ResponseDisconnect* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(reason_disconnect_, other->reason_disconnect_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseDisconnect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[15]);
}

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

class ResponseActiveChanged::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseActiveChanged>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseActiveChanged::ResponseActiveChanged(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseActiveChanged)
}
ResponseActiveChanged::ResponseActiveChanged(const ResponseActiveChanged& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseActiveChanged)
}

void ResponseActiveChanged::SharedCtor() {
id_ = 0;
}

ResponseActiveChanged::~ResponseActiveChanged() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseActiveChanged)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseActiveChanged::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseActiveChanged::ArenaDtor(void* object) {
  ResponseActiveChanged* _this = reinterpret_cast< ResponseActiveChanged* >(object);
  (void)_this;
}
void ResponseActiveChanged::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseActiveChanged::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseActiveChanged::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseActiveChanged)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseActiveChanged::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseActiveChanged::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseActiveChanged)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseActiveChanged)
  return target;
}

size_t ResponseActiveChanged::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseActiveChanged)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseActiveChanged::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseActiveChanged)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseActiveChanged* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseActiveChanged>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseActiveChanged)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseActiveChanged)
    MergeFrom(*source);
  }
}

void ResponseActiveChanged::MergeFrom(const ResponseActiveChanged& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseActiveChanged)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_id()) {
    _internal_set_id(from._internal_id());
  }
}

void ResponseActiveChanged::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseActiveChanged)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseActiveChanged::CopyFrom(const ResponseActiveChanged& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseActiveChanged)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseActiveChanged::IsInitialized() const {
  return true;
}

void ResponseActiveChanged::InternalSwap(ResponseActiveChanged* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(id_, other->id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseActiveChanged::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[16]);
}

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

class RequestSetTrackPosition::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestSetTrackPosition>()._has_bits_);
  static void set_has_position(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestSetTrackPosition::RequestSetTrackPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestSetTrackPosition)
}
RequestSetTrackPosition::RequestSetTrackPosition(const RequestSetTrackPosition& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  position_ = from.position_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestSetTrackPosition)
}

void RequestSetTrackPosition::SharedCtor() {
position_ = 0;
}

RequestSetTrackPosition::~RequestSetTrackPosition() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestSetTrackPosition)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestSetTrackPosition::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestSetTrackPosition::ArenaDtor(void* object) {
  RequestSetTrackPosition* _this = reinterpret_cast< RequestSetTrackPosition* >(object);
  (void)_this;
}
void RequestSetTrackPosition::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestSetTrackPosition::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestSetTrackPosition::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestSetTrackPosition)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  position_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestSetTrackPosition::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 position = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_position(&has_bits);
          position_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestSetTrackPosition::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestSetTrackPosition)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 position = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_position(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestSetTrackPosition)
  return target;
}

size_t RequestSetTrackPosition::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestSetTrackPosition)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 position = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_position());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestSetTrackPosition::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestSetTrackPosition)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestSetTrackPosition* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestSetTrackPosition>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestSetTrackPosition)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestSetTrackPosition)
    MergeFrom(*source);
  }
}

void RequestSetTrackPosition::MergeFrom(const RequestSetTrackPosition& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestSetTrackPosition)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_position()) {
    _internal_set_position(from._internal_position());
  }
}

void RequestSetTrackPosition::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestSetTrackPosition)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestSetTrackPosition::CopyFrom(const RequestSetTrackPosition& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestSetTrackPosition)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestSetTrackPosition::IsInitialized() const {
  return true;
}

void RequestSetTrackPosition::InternalSwap(RequestSetTrackPosition* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(position_, other->position_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestSetTrackPosition::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[17]);
}

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

class RequestInsertUrls::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestInsertUrls>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_position(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_play_now(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_enqueue(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_new_playlist_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestInsertUrls::RequestInsertUrls(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  urls_(arena),
  songs_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestInsertUrls)
}
RequestInsertUrls::RequestInsertUrls(const RequestInsertUrls& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      urls_(from.urls_),
      songs_(from.songs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_new_playlist_name()) {
    new_playlist_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_new_playlist_name(), 
      GetArena());
  }
  ::memcpy(&playlist_id_, &from.playlist_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&position_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(position_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestInsertUrls)
}

void RequestInsertUrls::SharedCtor() {
new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&playlist_id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&enqueue_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(enqueue_));
position_ = -1;
}

RequestInsertUrls::~RequestInsertUrls() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestInsertUrls)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestInsertUrls::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  new_playlist_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestInsertUrls::ArenaDtor(void* object) {
  RequestInsertUrls* _this = reinterpret_cast< RequestInsertUrls* >(object);
  (void)_this;
}
void RequestInsertUrls::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestInsertUrls::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestInsertUrls::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestInsertUrls)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  urls_.Clear();
  songs_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    new_playlist_name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000001eu) {
    ::memset(&playlist_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&enqueue_) -
        reinterpret_cast<char*>(&playlist_id_)) + sizeof(enqueue_));
    position_ = -1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestInsertUrls::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string urls = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_urls();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestInsertUrls.urls");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int32 position = 3 [default = -1];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_position(&has_bits);
          position_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool play_now = 4 [default = false];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_play_now(&has_bits);
          play_now_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool enqueue = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_enqueue(&has_bits);
          enqueue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .cpb.remote.SongMetadata songs = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_songs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      // optional string new_playlist_name = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_new_playlist_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestInsertUrls.new_playlist_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestInsertUrls::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestInsertUrls)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  // repeated string urls = 2;
  for (int i = 0, n = this->_internal_urls_size(); i < n; i++) {
    const auto& s = this->_internal_urls(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestInsertUrls.urls");
    target = stream->WriteString(2, s, target);
  }

  // optional int32 position = 3 [default = -1];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_position(), target);
  }

  // optional bool play_now = 4 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_play_now(), target);
  }

  // optional bool enqueue = 5 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_enqueue(), target);
  }

  // repeated .cpb.remote.SongMetadata songs = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_songs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_songs(i), target, stream);
  }

  // optional string new_playlist_name = 7;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_new_playlist_name().data(), static_cast<int>(this->_internal_new_playlist_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestInsertUrls.new_playlist_name");
    target = stream->WriteStringMaybeAliased(
        7, this->_internal_new_playlist_name(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestInsertUrls)
  return target;
}

size_t RequestInsertUrls::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestInsertUrls)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string urls = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(urls_.size());
  for (int i = 0, n = urls_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      urls_.Get(i));
  }

  // repeated .cpb.remote.SongMetadata songs = 6;
  total_size += 1UL * this->_internal_songs_size();
  for (const auto& msg : this->songs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string new_playlist_name = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_new_playlist_name());
    }

    // optional int32 playlist_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playlist_id());
    }

    // optional bool play_now = 4 [default = false];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional bool enqueue = 5 [default = false];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional int32 position = 3 [default = -1];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_position());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestInsertUrls::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestInsertUrls)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestInsertUrls* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestInsertUrls>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestInsertUrls)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestInsertUrls)
    MergeFrom(*source);
  }
}

void RequestInsertUrls::MergeFrom(const RequestInsertUrls& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestInsertUrls)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  urls_.MergeFrom(from.urls_);
  songs_.MergeFrom(from.songs_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_new_playlist_name(from._internal_new_playlist_name());
    }
    if (cached_has_bits & 0x00000002u) {
      playlist_id_ = from.playlist_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      play_now_ = from.play_now_;
    }
    if (cached_has_bits & 0x00000008u) {
      enqueue_ = from.enqueue_;
    }
    if (cached_has_bits & 0x00000010u) {
      position_ = from.position_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestInsertUrls::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestInsertUrls)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestInsertUrls::CopyFrom(const RequestInsertUrls& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestInsertUrls)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestInsertUrls::IsInitialized() const {
  return true;
}

void RequestInsertUrls::InternalSwap(RequestInsertUrls* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  urls_.InternalSwap(&other->urls_);
  songs_.InternalSwap(&other->songs_);
  new_playlist_name_.Swap(&other->new_playlist_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestInsertUrls, enqueue_)
      + sizeof(RequestInsertUrls::enqueue_)
      - PROTOBUF_FIELD_OFFSET(RequestInsertUrls, playlist_id_)>(
          reinterpret_cast<char*>(&playlist_id_),
          reinterpret_cast<char*>(&other->playlist_id_));
  swap(position_, other->position_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestInsertUrls::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[18]);
}

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

class RequestRemoveSongs::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestRemoveSongs>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestRemoveSongs::RequestRemoveSongs(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  songs_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestRemoveSongs)
}
RequestRemoveSongs::RequestRemoveSongs(const RequestRemoveSongs& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      songs_(from.songs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  playlist_id_ = from.playlist_id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestRemoveSongs)
}

void RequestRemoveSongs::SharedCtor() {
playlist_id_ = 0;
}

RequestRemoveSongs::~RequestRemoveSongs() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestRemoveSongs)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestRemoveSongs::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestRemoveSongs::ArenaDtor(void* object) {
  RequestRemoveSongs* _this = reinterpret_cast< RequestRemoveSongs* >(object);
  (void)_this;
}
void RequestRemoveSongs::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestRemoveSongs::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestRemoveSongs::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestRemoveSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  songs_.Clear();
  playlist_id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestRemoveSongs::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 songs = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_songs(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_songs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestRemoveSongs::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestRemoveSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  // repeated int32 songs = 2;
  for (int i = 0, n = this->_internal_songs_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_songs(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestRemoveSongs)
  return target;
}

size_t RequestRemoveSongs::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestRemoveSongs)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 songs = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->songs_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_songs_size());
    total_size += data_size;
  }

  // optional int32 playlist_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_playlist_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestRemoveSongs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestRemoveSongs)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestRemoveSongs* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestRemoveSongs>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestRemoveSongs)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestRemoveSongs)
    MergeFrom(*source);
  }
}

void RequestRemoveSongs::MergeFrom(const RequestRemoveSongs& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestRemoveSongs)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  songs_.MergeFrom(from.songs_);
  if (from._internal_has_playlist_id()) {
    _internal_set_playlist_id(from._internal_playlist_id());
  }
}

void RequestRemoveSongs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestRemoveSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestRemoveSongs::CopyFrom(const RequestRemoveSongs& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestRemoveSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestRemoveSongs::IsInitialized() const {
  return true;
}

void RequestRemoveSongs::InternalSwap(RequestRemoveSongs* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  songs_.InternalSwap(&other->songs_);
  swap(playlist_id_, other->playlist_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestRemoveSongs::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[19]);
}

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

class RequestOpenPlaylist::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestOpenPlaylist>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestOpenPlaylist::RequestOpenPlaylist(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestOpenPlaylist)
}
RequestOpenPlaylist::RequestOpenPlaylist(const RequestOpenPlaylist& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  playlist_id_ = from.playlist_id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestOpenPlaylist)
}

void RequestOpenPlaylist::SharedCtor() {
playlist_id_ = 0;
}

RequestOpenPlaylist::~RequestOpenPlaylist() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestOpenPlaylist)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestOpenPlaylist::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestOpenPlaylist::ArenaDtor(void* object) {
  RequestOpenPlaylist* _this = reinterpret_cast< RequestOpenPlaylist* >(object);
  (void)_this;
}
void RequestOpenPlaylist::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestOpenPlaylist::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestOpenPlaylist::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestOpenPlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  playlist_id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestOpenPlaylist::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestOpenPlaylist::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestOpenPlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestOpenPlaylist)
  return target;
}

size_t RequestOpenPlaylist::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestOpenPlaylist)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 playlist_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_playlist_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestOpenPlaylist::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestOpenPlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestOpenPlaylist* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestOpenPlaylist>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestOpenPlaylist)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestOpenPlaylist)
    MergeFrom(*source);
  }
}

void RequestOpenPlaylist::MergeFrom(const RequestOpenPlaylist& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestOpenPlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_playlist_id()) {
    _internal_set_playlist_id(from._internal_playlist_id());
  }
}

void RequestOpenPlaylist::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestOpenPlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestOpenPlaylist::CopyFrom(const RequestOpenPlaylist& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestOpenPlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestOpenPlaylist::IsInitialized() const {
  return true;
}

void RequestOpenPlaylist::InternalSwap(RequestOpenPlaylist* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(playlist_id_, other->playlist_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestOpenPlaylist::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[20]);
}

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

class RequestClosePlaylist::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestClosePlaylist>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestClosePlaylist::RequestClosePlaylist(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestClosePlaylist)
}
RequestClosePlaylist::RequestClosePlaylist(const RequestClosePlaylist& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  playlist_id_ = from.playlist_id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestClosePlaylist)
}

void RequestClosePlaylist::SharedCtor() {
playlist_id_ = 0;
}

RequestClosePlaylist::~RequestClosePlaylist() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestClosePlaylist)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestClosePlaylist::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestClosePlaylist::ArenaDtor(void* object) {
  RequestClosePlaylist* _this = reinterpret_cast< RequestClosePlaylist* >(object);
  (void)_this;
}
void RequestClosePlaylist::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestClosePlaylist::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestClosePlaylist::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestClosePlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  playlist_id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestClosePlaylist::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestClosePlaylist::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestClosePlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestClosePlaylist)
  return target;
}

size_t RequestClosePlaylist::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestClosePlaylist)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 playlist_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_playlist_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestClosePlaylist::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestClosePlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestClosePlaylist* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestClosePlaylist>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestClosePlaylist)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestClosePlaylist)
    MergeFrom(*source);
  }
}

void RequestClosePlaylist::MergeFrom(const RequestClosePlaylist& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestClosePlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_playlist_id()) {
    _internal_set_playlist_id(from._internal_playlist_id());
  }
}

void RequestClosePlaylist::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestClosePlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestClosePlaylist::CopyFrom(const RequestClosePlaylist& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestClosePlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestClosePlaylist::IsInitialized() const {
  return true;
}

void RequestClosePlaylist::InternalSwap(RequestClosePlaylist* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(playlist_id_, other->playlist_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestClosePlaylist::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[21]);
}

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

class RequestUpdatePlaylist::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestUpdatePlaylist>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_new_playlist_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_favorite(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_create_new_playlist(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_clear_playlist(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

RequestUpdatePlaylist::RequestUpdatePlaylist(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestUpdatePlaylist)
}
RequestUpdatePlaylist::RequestUpdatePlaylist(const RequestUpdatePlaylist& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_new_playlist_name()) {
    new_playlist_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_new_playlist_name(), 
      GetArena());
  }
  ::memcpy(&playlist_id_, &from.playlist_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&clear_playlist_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_playlist_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestUpdatePlaylist)
}

void RequestUpdatePlaylist::SharedCtor() {
new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&playlist_id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&clear_playlist_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_playlist_));
}

RequestUpdatePlaylist::~RequestUpdatePlaylist() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestUpdatePlaylist)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestUpdatePlaylist::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  new_playlist_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestUpdatePlaylist::ArenaDtor(void* object) {
  RequestUpdatePlaylist* _this = reinterpret_cast< RequestUpdatePlaylist* >(object);
  (void)_this;
}
void RequestUpdatePlaylist::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestUpdatePlaylist::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestUpdatePlaylist::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestUpdatePlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    new_playlist_name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000001eu) {
    ::memset(&playlist_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&clear_playlist_) -
        reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_playlist_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestUpdatePlaylist::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string new_playlist_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_new_playlist_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestUpdatePlaylist.new_playlist_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool favorite = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_favorite(&has_bits);
          favorite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool create_new_playlist = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_create_new_playlist(&has_bits);
          create_new_playlist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool clear_playlist = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_clear_playlist(&has_bits);
          clear_playlist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestUpdatePlaylist::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestUpdatePlaylist)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  // optional string new_playlist_name = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_new_playlist_name().data(), static_cast<int>(this->_internal_new_playlist_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestUpdatePlaylist.new_playlist_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_new_playlist_name(), target);
  }

  // optional bool favorite = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_favorite(), target);
  }

  // optional bool create_new_playlist = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_create_new_playlist(), target);
  }

  // optional bool clear_playlist = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_clear_playlist(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestUpdatePlaylist)
  return target;
}

size_t RequestUpdatePlaylist::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestUpdatePlaylist)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string new_playlist_name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_new_playlist_name());
    }

    // optional int32 playlist_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playlist_id());
    }

    // optional bool favorite = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional bool create_new_playlist = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool clear_playlist = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestUpdatePlaylist::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestUpdatePlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestUpdatePlaylist* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestUpdatePlaylist>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestUpdatePlaylist)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestUpdatePlaylist)
    MergeFrom(*source);
  }
}

void RequestUpdatePlaylist::MergeFrom(const RequestUpdatePlaylist& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestUpdatePlaylist)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_new_playlist_name(from._internal_new_playlist_name());
    }
    if (cached_has_bits & 0x00000002u) {
      playlist_id_ = from.playlist_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      favorite_ = from.favorite_;
    }
    if (cached_has_bits & 0x00000008u) {
      create_new_playlist_ = from.create_new_playlist_;
    }
    if (cached_has_bits & 0x00000010u) {
      clear_playlist_ = from.clear_playlist_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestUpdatePlaylist::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestUpdatePlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestUpdatePlaylist::CopyFrom(const RequestUpdatePlaylist& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestUpdatePlaylist)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestUpdatePlaylist::IsInitialized() const {
  return true;
}

void RequestUpdatePlaylist::InternalSwap(RequestUpdatePlaylist* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  new_playlist_name_.Swap(&other->new_playlist_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestUpdatePlaylist, clear_playlist_)
      + sizeof(RequestUpdatePlaylist::clear_playlist_)
      - PROTOBUF_FIELD_OFFSET(RequestUpdatePlaylist, playlist_id_)>(
          reinterpret_cast<char*>(&playlist_id_),
          reinterpret_cast<char*>(&other->playlist_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestUpdatePlaylist::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[22]);
}

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

class ResponseLyrics::_Internal {
 public:
};

ResponseLyrics::ResponseLyrics(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  lyrics_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseLyrics)
}
ResponseLyrics::ResponseLyrics(const ResponseLyrics& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      lyrics_(from.lyrics_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseLyrics)
}

void ResponseLyrics::SharedCtor() {
}

ResponseLyrics::~ResponseLyrics() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseLyrics)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseLyrics::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseLyrics::ArenaDtor(void* object) {
  ResponseLyrics* _this = reinterpret_cast< ResponseLyrics* >(object);
  (void)_this;
}
void ResponseLyrics::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseLyrics::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseLyrics::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseLyrics)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  lyrics_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseLyrics::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .cpb.remote.Lyric lyrics = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_lyrics(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseLyrics::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseLyrics)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .cpb.remote.Lyric lyrics = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_lyrics_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_lyrics(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseLyrics)
  return target;
}

size_t ResponseLyrics::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseLyrics)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.Lyric lyrics = 1;
  total_size += 1UL * this->_internal_lyrics_size();
  for (const auto& msg : this->lyrics_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseLyrics::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseLyrics)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseLyrics* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseLyrics>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseLyrics)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseLyrics)
    MergeFrom(*source);
  }
}

void ResponseLyrics::MergeFrom(const ResponseLyrics& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseLyrics)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  lyrics_.MergeFrom(from.lyrics_);
}

void ResponseLyrics::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseLyrics)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseLyrics::CopyFrom(const ResponseLyrics& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseLyrics)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseLyrics::IsInitialized() const {
  return true;
}

void ResponseLyrics::InternalSwap(ResponseLyrics* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  lyrics_.InternalSwap(&other->lyrics_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseLyrics::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[23]);
}

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

class Lyric::_Internal {
 public:
  using HasBits = decltype(std::declval<Lyric>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_title(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_content(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

Lyric::Lyric(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Lyric)
}
Lyric::Lyric(const Lyric& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_id()) {
    id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_id(), 
      GetArena());
  }
  title_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_title()) {
    title_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_title(), 
      GetArena());
  }
  content_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_content()) {
    content_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_content(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Lyric)
}

void Lyric::SharedCtor() {
id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
title_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
content_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Lyric::~Lyric() {
  // @@protoc_insertion_point(destructor:cpb.remote.Lyric)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Lyric::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  title_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  content_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Lyric::ArenaDtor(void* object) {
  Lyric* _this = reinterpret_cast< Lyric* >(object);
  (void)_this;
}
void Lyric::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Lyric::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Lyric::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Lyric)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      id_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      title_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      content_.ClearNonDefaultToEmpty();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Lyric::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Lyric.id");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string title = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_title();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Lyric.title");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string content = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_content();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Lyric.content");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Lyric::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Lyric)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Lyric.id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_id(), target);
  }

  // optional string title = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Lyric.title");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_title(), target);
  }

  // optional string content = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_content().data(), static_cast<int>(this->_internal_content().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Lyric.content");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_content(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Lyric)
  return target;
}

size_t Lyric::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Lyric)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_id());
    }

    // optional string title = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_title());
    }

    // optional string content = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_content());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Lyric::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Lyric)
  GOOGLE_DCHECK_NE(&from, this);
  const Lyric* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Lyric>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Lyric)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Lyric)
    MergeFrom(*source);
  }
}

void Lyric::MergeFrom(const Lyric& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Lyric)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_id(from._internal_id());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_title(from._internal_title());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_content(from._internal_content());
    }
  }
}

void Lyric::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Lyric)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Lyric::CopyFrom(const Lyric& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Lyric)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Lyric::IsInitialized() const {
  return true;
}

void Lyric::InternalSwap(Lyric* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  id_.Swap(&other->id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  title_.Swap(&other->title_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  content_.Swap(&other->content_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata Lyric::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[24]);
}

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

class RequestDownloadSongs::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestDownloadSongs>()._has_bits_);
  static void set_has_download_item(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_relative_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestDownloadSongs::RequestDownloadSongs(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  urls_(arena),
  songs_ids_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestDownloadSongs)
}
RequestDownloadSongs::RequestDownloadSongs(const RequestDownloadSongs& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      urls_(from.urls_),
      songs_ids_(from.songs_ids_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_relative_path()) {
    relative_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_relative_path(), 
      GetArena());
  }
  ::memcpy(&playlist_id_, &from.playlist_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&download_item_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(download_item_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestDownloadSongs)
}

void RequestDownloadSongs::SharedCtor() {
relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
playlist_id_ = 0;
download_item_ = 1;
}

RequestDownloadSongs::~RequestDownloadSongs() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestDownloadSongs)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestDownloadSongs::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  relative_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestDownloadSongs::ArenaDtor(void* object) {
  RequestDownloadSongs* _this = reinterpret_cast< RequestDownloadSongs* >(object);
  (void)_this;
}
void RequestDownloadSongs::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestDownloadSongs::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestDownloadSongs::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestDownloadSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  urls_.Clear();
  songs_ids_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    relative_path_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x00000006u) {
    playlist_id_ = 0;
    download_item_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestDownloadSongs::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .cpb.remote.DownloadItem download_item = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::DownloadItem_IsValid(val))) {
            _internal_set_download_item(static_cast<::cpb::remote::DownloadItem>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 playlist_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string urls = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_urls();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestDownloadSongs.urls");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated int32 songs_ids = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_songs_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_songs_ids(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string relative_path = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_relative_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestDownloadSongs.relative_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestDownloadSongs::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestDownloadSongs)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.DownloadItem download_item = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_download_item(), target);
  }

  // optional int32 playlist_id = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_playlist_id(), target);
  }

  // repeated string urls = 3;
  for (int i = 0, n = this->_internal_urls_size(); i < n; i++) {
    const auto& s = this->_internal_urls(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestDownloadSongs.urls");
    target = stream->WriteString(3, s, target);
  }

  // repeated int32 songs_ids = 4;
  for (int i = 0, n = this->_internal_songs_ids_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_songs_ids(i), target);
  }

  // optional string relative_path = 5;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_relative_path().data(), static_cast<int>(this->_internal_relative_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestDownloadSongs.relative_path");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_relative_path(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestDownloadSongs)
  return target;
}

size_t RequestDownloadSongs::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestDownloadSongs)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string urls = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(urls_.size());
  for (int i = 0, n = urls_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      urls_.Get(i));
  }

  // repeated int32 songs_ids = 4;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->songs_ids_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_songs_ids_size());
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string relative_path = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_relative_path());
    }

    // optional int32 playlist_id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playlist_id());
    }

    // optional .cpb.remote.DownloadItem download_item = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_download_item());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestDownloadSongs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestDownloadSongs)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestDownloadSongs* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestDownloadSongs>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestDownloadSongs)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestDownloadSongs)
    MergeFrom(*source);
  }
}

void RequestDownloadSongs::MergeFrom(const RequestDownloadSongs& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestDownloadSongs)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  urls_.MergeFrom(from.urls_);
  songs_ids_.MergeFrom(from.songs_ids_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_relative_path(from._internal_relative_path());
    }
    if (cached_has_bits & 0x00000002u) {
      playlist_id_ = from.playlist_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      download_item_ = from.download_item_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestDownloadSongs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestDownloadSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestDownloadSongs::CopyFrom(const RequestDownloadSongs& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestDownloadSongs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestDownloadSongs::IsInitialized() const {
  return true;
}

void RequestDownloadSongs::InternalSwap(RequestDownloadSongs* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  urls_.InternalSwap(&other->urls_);
  songs_ids_.InternalSwap(&other->songs_ids_);
  relative_path_.Swap(&other->relative_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(playlist_id_, other->playlist_id_);
  swap(download_item_, other->download_item_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestDownloadSongs::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[25]);
}

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

class ResponseSongFileChunk::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseSongFileChunk>()._has_bits_);
  static void set_has_chunk_number(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_chunk_count(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_file_number(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_file_count(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::cpb::remote::SongMetadata& song_metadata(const ResponseSongFileChunk* msg);
  static void set_has_song_metadata(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_file_hash(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::cpb::remote::SongMetadata&
ResponseSongFileChunk::_Internal::song_metadata(const ResponseSongFileChunk* msg) {
  return *msg->song_metadata_;
}
ResponseSongFileChunk::ResponseSongFileChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseSongFileChunk)
}
ResponseSongFileChunk::ResponseSongFileChunk(const ResponseSongFileChunk& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArena());
  }
  file_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_file_hash()) {
    file_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_file_hash(), 
      GetArena());
  }
  if (from._internal_has_song_metadata()) {
    song_metadata_ = new ::cpb::remote::SongMetadata(*from.song_metadata_);
  } else {
    song_metadata_ = nullptr;
  }
  ::memcpy(&chunk_number_, &from.chunk_number_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&chunk_number_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseSongFileChunk)
}

void ResponseSongFileChunk::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
file_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&song_metadata_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&song_metadata_)) + sizeof(size_));
}

ResponseSongFileChunk::~ResponseSongFileChunk() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseSongFileChunk)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseSongFileChunk::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  file_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete song_metadata_;
}

void ResponseSongFileChunk::ArenaDtor(void* object) {
  ResponseSongFileChunk* _this = reinterpret_cast< ResponseSongFileChunk* >(object);
  (void)_this;
}
void ResponseSongFileChunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseSongFileChunk::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseSongFileChunk::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseSongFileChunk)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      file_hash_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(song_metadata_ != nullptr);
      song_metadata_->Clear();
    }
  }
  if (cached_has_bits & 0x000000f8u) {
    ::memset(&chunk_number_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&chunk_number_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseSongFileChunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 chunk_number = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_chunk_number(&has_bits);
          chunk_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 chunk_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_chunk_count(&has_bits);
          chunk_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 file_number = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_file_number(&has_bits);
          file_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 file_count = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_file_count(&has_bits);
          file_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.SongMetadata song_metadata = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_song_metadata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 size = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes file_hash = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          auto str = _internal_mutable_file_hash();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseSongFileChunk::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseSongFileChunk)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 chunk_number = 1;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_chunk_number(), target);
  }

  // optional int32 chunk_count = 2;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_chunk_count(), target);
  }

  // optional int32 file_number = 3;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_file_number(), target);
  }

  // optional int32 file_count = 4;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_file_count(), target);
  }

  // optional .cpb.remote.SongMetadata song_metadata = 6;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::song_metadata(this), target, stream);
  }

  // optional bytes data = 7;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        7, this->_internal_data(), target);
  }

  // optional int32 size = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_size(), target);
  }

  // optional bytes file_hash = 9;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        9, this->_internal_file_hash(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseSongFileChunk)
  return target;
}

size_t ResponseSongFileChunk::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseSongFileChunk)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional bytes data = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional bytes file_hash = 9;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_file_hash());
    }

    // optional .cpb.remote.SongMetadata song_metadata = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *song_metadata_);
    }

    // optional int32 chunk_number = 1;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_chunk_number());
    }

    // optional int32 chunk_count = 2;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_chunk_count());
    }

    // optional int32 file_number = 3;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_file_number());
    }

    // optional int32 file_count = 4;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_file_count());
    }

    // optional int32 size = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_size());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseSongFileChunk::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseSongFileChunk)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseSongFileChunk* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseSongFileChunk>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseSongFileChunk)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseSongFileChunk)
    MergeFrom(*source);
  }
}

void ResponseSongFileChunk::MergeFrom(const ResponseSongFileChunk& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseSongFileChunk)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_file_hash(from._internal_file_hash());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_song_metadata()->::cpb::remote::SongMetadata::MergeFrom(from._internal_song_metadata());
    }
    if (cached_has_bits & 0x00000008u) {
      chunk_number_ = from.chunk_number_;
    }
    if (cached_has_bits & 0x00000010u) {
      chunk_count_ = from.chunk_count_;
    }
    if (cached_has_bits & 0x00000020u) {
      file_number_ = from.file_number_;
    }
    if (cached_has_bits & 0x00000040u) {
      file_count_ = from.file_count_;
    }
    if (cached_has_bits & 0x00000080u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseSongFileChunk::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseSongFileChunk)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseSongFileChunk::CopyFrom(const ResponseSongFileChunk& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseSongFileChunk)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseSongFileChunk::IsInitialized() const {
  return true;
}

void ResponseSongFileChunk::InternalSwap(ResponseSongFileChunk* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  file_hash_.Swap(&other->file_hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseSongFileChunk, size_)
      + sizeof(ResponseSongFileChunk::size_)
      - PROTOBUF_FIELD_OFFSET(ResponseSongFileChunk, song_metadata_)>(
          reinterpret_cast<char*>(&song_metadata_),
          reinterpret_cast<char*>(&other->song_metadata_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseSongFileChunk::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[26]);
}

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

class ResponseLibraryChunk::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseLibraryChunk>()._has_bits_);
  static void set_has_chunk_number(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_chunk_count(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_file_hash(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

ResponseLibraryChunk::ResponseLibraryChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseLibraryChunk)
}
ResponseLibraryChunk::ResponseLibraryChunk(const ResponseLibraryChunk& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArena());
  }
  file_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_file_hash()) {
    file_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_file_hash(), 
      GetArena());
  }
  ::memcpy(&chunk_number_, &from.chunk_number_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&chunk_number_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseLibraryChunk)
}

void ResponseLibraryChunk::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
file_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&chunk_number_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&chunk_number_)) + sizeof(size_));
}

ResponseLibraryChunk::~ResponseLibraryChunk() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseLibraryChunk)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseLibraryChunk::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  file_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ResponseLibraryChunk::ArenaDtor(void* object) {
  ResponseLibraryChunk* _this = reinterpret_cast< ResponseLibraryChunk* >(object);
  (void)_this;
}
void ResponseLibraryChunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseLibraryChunk::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseLibraryChunk::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseLibraryChunk)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      file_hash_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&chunk_number_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&chunk_number_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseLibraryChunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 chunk_number = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_chunk_number(&has_bits);
          chunk_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 chunk_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_chunk_count(&has_bits);
          chunk_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 size = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes file_hash = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_file_hash();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseLibraryChunk::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseLibraryChunk)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 chunk_number = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_chunk_number(), target);
  }

  // optional int32 chunk_count = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_chunk_count(), target);
  }

  // optional bytes data = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_data(), target);
  }

  // optional int32 size = 4;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_size(), target);
  }

  // optional bytes file_hash = 5;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        5, this->_internal_file_hash(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseLibraryChunk)
  return target;
}

size_t ResponseLibraryChunk::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseLibraryChunk)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional bytes data = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional bytes file_hash = 5;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_file_hash());
    }

    // optional int32 chunk_number = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_chunk_number());
    }

    // optional int32 chunk_count = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_chunk_count());
    }

    // optional int32 size = 4;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_size());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseLibraryChunk::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseLibraryChunk)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseLibraryChunk* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseLibraryChunk>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseLibraryChunk)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseLibraryChunk)
    MergeFrom(*source);
  }
}

void ResponseLibraryChunk::MergeFrom(const ResponseLibraryChunk& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseLibraryChunk)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_file_hash(from._internal_file_hash());
    }
    if (cached_has_bits & 0x00000004u) {
      chunk_number_ = from.chunk_number_;
    }
    if (cached_has_bits & 0x00000008u) {
      chunk_count_ = from.chunk_count_;
    }
    if (cached_has_bits & 0x00000010u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseLibraryChunk::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseLibraryChunk)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseLibraryChunk::CopyFrom(const ResponseLibraryChunk& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseLibraryChunk)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseLibraryChunk::IsInitialized() const {
  return true;
}

void ResponseLibraryChunk::InternalSwap(ResponseLibraryChunk* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  file_hash_.Swap(&other->file_hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseLibraryChunk, size_)
      + sizeof(ResponseLibraryChunk::size_)
      - PROTOBUF_FIELD_OFFSET(ResponseLibraryChunk, chunk_number_)>(
          reinterpret_cast<char*>(&chunk_number_),
          reinterpret_cast<char*>(&other->chunk_number_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseLibraryChunk::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[27]);
}

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

class ResponseSongOffer::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseSongOffer>()._has_bits_);
  static void set_has_accepted(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseSongOffer::ResponseSongOffer(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseSongOffer)
}
ResponseSongOffer::ResponseSongOffer(const ResponseSongOffer& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  accepted_ = from.accepted_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseSongOffer)
}

void ResponseSongOffer::SharedCtor() {
accepted_ = false;
}

ResponseSongOffer::~ResponseSongOffer() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseSongOffer)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseSongOffer::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseSongOffer::ArenaDtor(void* object) {
  ResponseSongOffer* _this = reinterpret_cast< ResponseSongOffer* >(object);
  (void)_this;
}
void ResponseSongOffer::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseSongOffer::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseSongOffer::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseSongOffer)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  accepted_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseSongOffer::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bool accepted = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_accepted(&has_bits);
          accepted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseSongOffer::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseSongOffer)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool accepted = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_accepted(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseSongOffer)
  return target;
}

size_t ResponseSongOffer::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseSongOffer)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool accepted = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseSongOffer::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseSongOffer)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseSongOffer* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseSongOffer>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseSongOffer)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseSongOffer)
    MergeFrom(*source);
  }
}

void ResponseSongOffer::MergeFrom(const ResponseSongOffer& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseSongOffer)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_accepted()) {
    _internal_set_accepted(from._internal_accepted());
  }
}

void ResponseSongOffer::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseSongOffer)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseSongOffer::CopyFrom(const ResponseSongOffer& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseSongOffer)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseSongOffer::IsInitialized() const {
  return true;
}

void ResponseSongOffer::InternalSwap(ResponseSongOffer* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(accepted_, other->accepted_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseSongOffer::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[28]);
}

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

class RequestRateSong::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestRateSong>()._has_bits_);
  static void set_has_rating(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestRateSong::RequestRateSong(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestRateSong)
}
RequestRateSong::RequestRateSong(const RequestRateSong& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  rating_ = from.rating_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestRateSong)
}

void RequestRateSong::SharedCtor() {
rating_ = 0;
}

RequestRateSong::~RequestRateSong() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestRateSong)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestRateSong::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RequestRateSong::ArenaDtor(void* object) {
  RequestRateSong* _this = reinterpret_cast< RequestRateSong* >(object);
  (void)_this;
}
void RequestRateSong::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestRateSong::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestRateSong::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestRateSong)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  rating_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestRateSong::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional float rating = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_rating(&has_bits);
          rating_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestRateSong::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestRateSong)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float rating = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_rating(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestRateSong)
  return target;
}

size_t RequestRateSong::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestRateSong)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional float rating = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestRateSong::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestRateSong)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestRateSong* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestRateSong>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestRateSong)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestRateSong)
    MergeFrom(*source);
  }
}

void RequestRateSong::MergeFrom(const RequestRateSong& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestRateSong)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_rating()) {
    _internal_set_rating(from._internal_rating());
  }
}

void RequestRateSong::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestRateSong)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestRateSong::CopyFrom(const RequestRateSong& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestRateSong)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestRateSong::IsInitialized() const {
  return true;
}

void RequestRateSong::InternalSwap(RequestRateSong* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(rating_, other->rating_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestRateSong::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[29]);
}

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

class ResponseDownloadTotalSize::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseDownloadTotalSize>()._has_bits_);
  static void set_has_total_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_file_count(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

ResponseDownloadTotalSize::ResponseDownloadTotalSize(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseDownloadTotalSize)
}
ResponseDownloadTotalSize::ResponseDownloadTotalSize(const ResponseDownloadTotalSize& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&total_size_, &from.total_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&file_count_) -
    reinterpret_cast<char*>(&total_size_)) + sizeof(file_count_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseDownloadTotalSize)
}

void ResponseDownloadTotalSize::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&total_size_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&file_count_) -
    reinterpret_cast<char*>(&total_size_)) + sizeof(file_count_));
}

ResponseDownloadTotalSize::~ResponseDownloadTotalSize() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseDownloadTotalSize)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseDownloadTotalSize::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseDownloadTotalSize::ArenaDtor(void* object) {
  ResponseDownloadTotalSize* _this = reinterpret_cast< ResponseDownloadTotalSize* >(object);
  (void)_this;
}
void ResponseDownloadTotalSize::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseDownloadTotalSize::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseDownloadTotalSize::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseDownloadTotalSize)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&total_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&file_count_) -
        reinterpret_cast<char*>(&total_size_)) + sizeof(file_count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseDownloadTotalSize::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 total_size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_total_size(&has_bits);
          total_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 file_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_file_count(&has_bits);
          file_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseDownloadTotalSize::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseDownloadTotalSize)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 total_size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_total_size(), target);
  }

  // optional int32 file_count = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_file_count(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseDownloadTotalSize)
  return target;
}

size_t ResponseDownloadTotalSize::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseDownloadTotalSize)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 total_size = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_total_size());
    }

    // optional int32 file_count = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_file_count());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseDownloadTotalSize::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseDownloadTotalSize)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseDownloadTotalSize* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseDownloadTotalSize>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseDownloadTotalSize)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseDownloadTotalSize)
    MergeFrom(*source);
  }
}

void ResponseDownloadTotalSize::MergeFrom(const ResponseDownloadTotalSize& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseDownloadTotalSize)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      total_size_ = from.total_size_;
    }
    if (cached_has_bits & 0x00000002u) {
      file_count_ = from.file_count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseDownloadTotalSize::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseDownloadTotalSize)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseDownloadTotalSize::CopyFrom(const ResponseDownloadTotalSize& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseDownloadTotalSize)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseDownloadTotalSize::IsInitialized() const {
  return true;
}

void ResponseDownloadTotalSize::InternalSwap(ResponseDownloadTotalSize* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseDownloadTotalSize, file_count_)
      + sizeof(ResponseDownloadTotalSize::file_count_)
      - PROTOBUF_FIELD_OFFSET(ResponseDownloadTotalSize, total_size_)>(
          reinterpret_cast<char*>(&total_size_),
          reinterpret_cast<char*>(&other->total_size_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseDownloadTotalSize::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[30]);
}

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

class RequestGlobalSearch::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestGlobalSearch>()._has_bits_);
  static void set_has_query(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestGlobalSearch::RequestGlobalSearch(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestGlobalSearch)
}
RequestGlobalSearch::RequestGlobalSearch(const RequestGlobalSearch& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_query()) {
    query_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_query(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestGlobalSearch)
}

void RequestGlobalSearch::SharedCtor() {
query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

RequestGlobalSearch::~RequestGlobalSearch() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestGlobalSearch)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestGlobalSearch::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  query_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestGlobalSearch::ArenaDtor(void* object) {
  RequestGlobalSearch* _this = reinterpret_cast< RequestGlobalSearch* >(object);
  (void)_this;
}
void RequestGlobalSearch::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestGlobalSearch::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestGlobalSearch::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestGlobalSearch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    query_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestGlobalSearch::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string query = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_query();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestGlobalSearch.query");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestGlobalSearch::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestGlobalSearch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string query = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_query().data(), static_cast<int>(this->_internal_query().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestGlobalSearch.query");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_query(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestGlobalSearch)
  return target;
}

size_t RequestGlobalSearch::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestGlobalSearch)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string query = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_query());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestGlobalSearch::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestGlobalSearch)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestGlobalSearch* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestGlobalSearch>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestGlobalSearch)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestGlobalSearch)
    MergeFrom(*source);
  }
}

void RequestGlobalSearch::MergeFrom(const RequestGlobalSearch& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestGlobalSearch)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_query()) {
    _internal_set_query(from._internal_query());
  }
}

void RequestGlobalSearch::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestGlobalSearch)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestGlobalSearch::CopyFrom(const RequestGlobalSearch& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestGlobalSearch)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestGlobalSearch::IsInitialized() const {
  return true;
}

void RequestGlobalSearch::InternalSwap(RequestGlobalSearch* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  query_.Swap(&other->query_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestGlobalSearch::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[31]);
}

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

class ResponseGlobalSearch::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseGlobalSearch>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_query(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_search_provider(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_search_provider_icon(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

ResponseGlobalSearch::ResponseGlobalSearch(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  song_metadata_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseGlobalSearch)
}
ResponseGlobalSearch::ResponseGlobalSearch(const ResponseGlobalSearch& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      song_metadata_(from.song_metadata_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_query()) {
    query_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_query(), 
      GetArena());
  }
  search_provider_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_search_provider()) {
    search_provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_search_provider(), 
      GetArena());
  }
  search_provider_icon_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_search_provider_icon()) {
    search_provider_icon_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_search_provider_icon(), 
      GetArena());
  }
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseGlobalSearch)
}

void ResponseGlobalSearch::SharedCtor() {
query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
search_provider_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
search_provider_icon_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
id_ = 0;
}

ResponseGlobalSearch::~ResponseGlobalSearch() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseGlobalSearch)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseGlobalSearch::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  query_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  search_provider_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  search_provider_icon_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ResponseGlobalSearch::ArenaDtor(void* object) {
  ResponseGlobalSearch* _this = reinterpret_cast< ResponseGlobalSearch* >(object);
  (void)_this;
}
void ResponseGlobalSearch::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseGlobalSearch::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseGlobalSearch::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseGlobalSearch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  song_metadata_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      query_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      search_provider_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      search_provider_icon_.ClearNonDefaultToEmpty();
    }
  }
  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseGlobalSearch::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string query = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_query();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseGlobalSearch.query");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string search_provider = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_search_provider();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseGlobalSearch.search_provider");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .cpb.remote.SongMetadata song_metadata = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_song_metadata(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bytes search_provider_icon = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_search_provider_icon();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseGlobalSearch::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseGlobalSearch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  // optional string query = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_query().data(), static_cast<int>(this->_internal_query().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseGlobalSearch.query");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_query(), target);
  }

  // optional string search_provider = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_search_provider().data(), static_cast<int>(this->_internal_search_provider().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseGlobalSearch.search_provider");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_search_provider(), target);
  }

  // repeated .cpb.remote.SongMetadata song_metadata = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_song_metadata_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_song_metadata(i), target, stream);
  }

  // optional bytes search_provider_icon = 5;
  if (cached_has_bits & 0x00000004u) {
    target = stream->WriteBytesMaybeAliased(
        5, this->_internal_search_provider_icon(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseGlobalSearch)
  return target;
}

size_t ResponseGlobalSearch::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseGlobalSearch)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.SongMetadata song_metadata = 4;
  total_size += 1UL * this->_internal_song_metadata_size();
  for (const auto& msg : this->song_metadata_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string query = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_query());
    }

    // optional string search_provider = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_search_provider());
    }

    // optional bytes search_provider_icon = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_search_provider_icon());
    }

    // optional int32 id = 1;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_id());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseGlobalSearch::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseGlobalSearch)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseGlobalSearch* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseGlobalSearch>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseGlobalSearch)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseGlobalSearch)
    MergeFrom(*source);
  }
}

void ResponseGlobalSearch::MergeFrom(const ResponseGlobalSearch& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseGlobalSearch)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  song_metadata_.MergeFrom(from.song_metadata_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_query(from._internal_query());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_search_provider(from._internal_search_provider());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_search_provider_icon(from._internal_search_provider_icon());
    }
    if (cached_has_bits & 0x00000008u) {
      id_ = from.id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseGlobalSearch::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseGlobalSearch)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseGlobalSearch::CopyFrom(const ResponseGlobalSearch& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseGlobalSearch)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseGlobalSearch::IsInitialized() const {
  return true;
}

void ResponseGlobalSearch::InternalSwap(ResponseGlobalSearch* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  song_metadata_.InternalSwap(&other->song_metadata_);
  query_.Swap(&other->query_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  search_provider_.Swap(&other->search_provider_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  search_provider_icon_.Swap(&other->search_provider_icon_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(id_, other->id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseGlobalSearch::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[32]);
}

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

class ResponseTranscoderStatus::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseTranscoderStatus>()._has_bits_);
  static void set_has_processed(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_total(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

ResponseTranscoderStatus::ResponseTranscoderStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseTranscoderStatus)
}
ResponseTranscoderStatus::ResponseTranscoderStatus(const ResponseTranscoderStatus& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&processed_, &from.processed_,
    static_cast<size_t>(reinterpret_cast<char*>(&total_) -
    reinterpret_cast<char*>(&processed_)) + sizeof(total_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseTranscoderStatus)
}

void ResponseTranscoderStatus::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&processed_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&total_) -
    reinterpret_cast<char*>(&processed_)) + sizeof(total_));
}

ResponseTranscoderStatus::~ResponseTranscoderStatus() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseTranscoderStatus)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseTranscoderStatus::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseTranscoderStatus::ArenaDtor(void* object) {
  ResponseTranscoderStatus* _this = reinterpret_cast< ResponseTranscoderStatus* >(object);
  (void)_this;
}
void ResponseTranscoderStatus::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseTranscoderStatus::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseTranscoderStatus::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseTranscoderStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&processed_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_) -
        reinterpret_cast<char*>(&processed_)) + sizeof(total_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseTranscoderStatus::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 processed = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_processed(&has_bits);
          processed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 total = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_total(&has_bits);
          total_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseTranscoderStatus::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseTranscoderStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 processed = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_processed(), target);
  }

  // optional int32 total = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_total(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseTranscoderStatus)
  return target;
}

size_t ResponseTranscoderStatus::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseTranscoderStatus)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 processed = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_processed());
    }

    // optional int32 total = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_total());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseTranscoderStatus::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseTranscoderStatus)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseTranscoderStatus* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseTranscoderStatus>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseTranscoderStatus)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseTranscoderStatus)
    MergeFrom(*source);
  }
}

void ResponseTranscoderStatus::MergeFrom(const ResponseTranscoderStatus& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseTranscoderStatus)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      processed_ = from.processed_;
    }
    if (cached_has_bits & 0x00000002u) {
      total_ = from.total_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseTranscoderStatus::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseTranscoderStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseTranscoderStatus::CopyFrom(const ResponseTranscoderStatus& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseTranscoderStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseTranscoderStatus::IsInitialized() const {
  return true;
}

void ResponseTranscoderStatus::InternalSwap(ResponseTranscoderStatus* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseTranscoderStatus, total_)
      + sizeof(ResponseTranscoderStatus::total_)
      - PROTOBUF_FIELD_OFFSET(ResponseTranscoderStatus, processed_)>(
          reinterpret_cast<char*>(&processed_),
          reinterpret_cast<char*>(&other->processed_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseTranscoderStatus::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[33]);
}

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

class ResponseGlobalSearchStatus::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseGlobalSearchStatus>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_query(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_status(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

ResponseGlobalSearchStatus::ResponseGlobalSearchStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseGlobalSearchStatus)
}
ResponseGlobalSearchStatus::ResponseGlobalSearchStatus(const ResponseGlobalSearchStatus& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_query()) {
    query_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_query(), 
      GetArena());
  }
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&id_)) + sizeof(status_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseGlobalSearchStatus)
}

void ResponseGlobalSearchStatus::SharedCtor() {
query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
id_ = 0;
status_ = 1;
}

ResponseGlobalSearchStatus::~ResponseGlobalSearchStatus() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseGlobalSearchStatus)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseGlobalSearchStatus::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  query_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ResponseGlobalSearchStatus::ArenaDtor(void* object) {
  ResponseGlobalSearchStatus* _this = reinterpret_cast< ResponseGlobalSearchStatus* >(object);
  (void)_this;
}
void ResponseGlobalSearchStatus::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseGlobalSearchStatus::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseGlobalSearchStatus::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseGlobalSearchStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    query_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x00000006u) {
    id_ = 0;
    status_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseGlobalSearchStatus::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string query = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_query();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseGlobalSearchStatus.query");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.GlobalSearchStatus status = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::GlobalSearchStatus_IsValid(val))) {
            _internal_set_status(static_cast<::cpb::remote::GlobalSearchStatus>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseGlobalSearchStatus::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseGlobalSearchStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
  }

  // optional string query = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_query().data(), static_cast<int>(this->_internal_query().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseGlobalSearchStatus.query");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_query(), target);
  }

  // optional .cpb.remote.GlobalSearchStatus status = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_status(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseGlobalSearchStatus)
  return target;
}

size_t ResponseGlobalSearchStatus::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseGlobalSearchStatus)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string query = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_query());
    }

    // optional int32 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_id());
    }

    // optional .cpb.remote.GlobalSearchStatus status = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseGlobalSearchStatus::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseGlobalSearchStatus)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseGlobalSearchStatus* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseGlobalSearchStatus>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseGlobalSearchStatus)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseGlobalSearchStatus)
    MergeFrom(*source);
  }
}

void ResponseGlobalSearchStatus::MergeFrom(const ResponseGlobalSearchStatus& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseGlobalSearchStatus)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_query(from._internal_query());
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseGlobalSearchStatus::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseGlobalSearchStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseGlobalSearchStatus::CopyFrom(const ResponseGlobalSearchStatus& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseGlobalSearchStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseGlobalSearchStatus::IsInitialized() const {
  return true;
}

void ResponseGlobalSearchStatus::InternalSwap(ResponseGlobalSearchStatus* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  query_.Swap(&other->query_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(id_, other->id_);
  swap(status_, other->status_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseGlobalSearchStatus::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[34]);
}

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

class RequestListFiles::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestListFiles>()._has_bits_);
  static void set_has_relative_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestListFiles::RequestListFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestListFiles)
}
RequestListFiles::RequestListFiles(const RequestListFiles& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_relative_path()) {
    relative_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_relative_path(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestListFiles)
}

void RequestListFiles::SharedCtor() {
relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

RequestListFiles::~RequestListFiles() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestListFiles)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestListFiles::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  relative_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestListFiles::ArenaDtor(void* object) {
  RequestListFiles* _this = reinterpret_cast< RequestListFiles* >(object);
  (void)_this;
}
void RequestListFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestListFiles::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestListFiles::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestListFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    relative_path_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestListFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string relative_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_relative_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestListFiles.relative_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestListFiles::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestListFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string relative_path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_relative_path().data(), static_cast<int>(this->_internal_relative_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestListFiles.relative_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_relative_path(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestListFiles)
  return target;
}

size_t RequestListFiles::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestListFiles)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string relative_path = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_relative_path());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestListFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestListFiles)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestListFiles* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestListFiles>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestListFiles)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestListFiles)
    MergeFrom(*source);
  }
}

void RequestListFiles::MergeFrom(const RequestListFiles& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestListFiles)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_relative_path()) {
    _internal_set_relative_path(from._internal_relative_path());
  }
}

void RequestListFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestListFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestListFiles::CopyFrom(const RequestListFiles& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestListFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestListFiles::IsInitialized() const {
  return true;
}

void RequestListFiles::InternalSwap(RequestListFiles* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  relative_path_.Swap(&other->relative_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestListFiles::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[35]);
}

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

class FileMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<FileMetadata>()._has_bits_);
  static void set_has_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_is_dir(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

FileMetadata::FileMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.FileMetadata)
}
FileMetadata::FileMetadata(const FileMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_filename()) {
    filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_filename(), 
      GetArena());
  }
  is_dir_ = from.is_dir_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.FileMetadata)
}

void FileMetadata::SharedCtor() {
filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
is_dir_ = false;
}

FileMetadata::~FileMetadata() {
  // @@protoc_insertion_point(destructor:cpb.remote.FileMetadata)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void FileMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void FileMetadata::ArenaDtor(void* object) {
  FileMetadata* _this = reinterpret_cast< FileMetadata* >(object);
  (void)_this;
}
void FileMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void FileMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void FileMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.FileMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    filename_.ClearNonDefaultToEmpty();
  }
  is_dir_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FileMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string filename = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_filename();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.FileMetadata.filename");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_dir = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_is_dir(&has_bits);
          is_dir_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* FileMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.FileMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string filename = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_filename().data(), static_cast<int>(this->_internal_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.FileMetadata.filename");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_filename(), target);
  }

  // optional bool is_dir = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_is_dir(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.FileMetadata)
  return target;
}

size_t FileMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.FileMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string filename = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_filename());
    }

    // optional bool is_dir = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void FileMetadata::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.FileMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  const FileMetadata* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FileMetadata>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.FileMetadata)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.FileMetadata)
    MergeFrom(*source);
  }
}

void FileMetadata::MergeFrom(const FileMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.FileMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_filename(from._internal_filename());
    }
    if (cached_has_bits & 0x00000002u) {
      is_dir_ = from.is_dir_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FileMetadata::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.FileMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void FileMetadata::CopyFrom(const FileMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.FileMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FileMetadata::IsInitialized() const {
  return true;
}

void FileMetadata::InternalSwap(FileMetadata* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  filename_.Swap(&other->filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(is_dir_, other->is_dir_);
}

::PROTOBUF_NAMESPACE_ID::Metadata FileMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[36]);
}

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

class ResponseListFiles::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseListFiles>()._has_bits_);
  static void set_has_relative_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

ResponseListFiles::ResponseListFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  files_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseListFiles)
}
ResponseListFiles::ResponseListFiles(const ResponseListFiles& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      files_(from.files_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_relative_path()) {
    relative_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_relative_path(), 
      GetArena());
  }
  error_ = from.error_;
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseListFiles)
}

void ResponseListFiles::SharedCtor() {
relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
error_ = 0;
}

ResponseListFiles::~ResponseListFiles() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseListFiles)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseListFiles::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  relative_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ResponseListFiles::ArenaDtor(void* object) {
  ResponseListFiles* _this = reinterpret_cast< ResponseListFiles* >(object);
  (void)_this;
}
void ResponseListFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseListFiles::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseListFiles::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseListFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  files_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    relative_path_.ClearNonDefaultToEmpty();
  }
  error_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseListFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string relative_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_relative_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.ResponseListFiles.relative_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .cpb.remote.FileMetadata files = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_files(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseListFiles.Error error = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::ResponseListFiles_Error_IsValid(val))) {
            _internal_set_error(static_cast<::cpb::remote::ResponseListFiles_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseListFiles::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseListFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string relative_path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_relative_path().data(), static_cast<int>(this->_internal_relative_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.ResponseListFiles.relative_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_relative_path(), target);
  }

  // repeated .cpb.remote.FileMetadata files = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_files_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_files(i), target, stream);
  }

  // optional .cpb.remote.ResponseListFiles.Error error = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_error(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseListFiles)
  return target;
}

size_t ResponseListFiles::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseListFiles)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.FileMetadata files = 2;
  total_size += 1UL * this->_internal_files_size();
  for (const auto& msg : this->files_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string relative_path = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_relative_path());
    }

    // optional .cpb.remote.ResponseListFiles.Error error = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseListFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseListFiles)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseListFiles* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseListFiles>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseListFiles)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseListFiles)
    MergeFrom(*source);
  }
}

void ResponseListFiles::MergeFrom(const ResponseListFiles& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseListFiles)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  files_.MergeFrom(from.files_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_relative_path(from._internal_relative_path());
    }
    if (cached_has_bits & 0x00000002u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ResponseListFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseListFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseListFiles::CopyFrom(const ResponseListFiles& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseListFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseListFiles::IsInitialized() const {
  return true;
}

void ResponseListFiles::InternalSwap(ResponseListFiles* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  files_.InternalSwap(&other->files_);
  relative_path_.Swap(&other->relative_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(error_, other->error_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseListFiles::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[37]);
}

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

class RequestAppendFiles::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestAppendFiles>()._has_bits_);
  static void set_has_playlist_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_new_playlist_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_relative_path(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_play_now(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_clear_first(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

RequestAppendFiles::RequestAppendFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  files_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.RequestAppendFiles)
}
RequestAppendFiles::RequestAppendFiles(const RequestAppendFiles& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      files_(from.files_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_new_playlist_name()) {
    new_playlist_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_new_playlist_name(), 
      GetArena());
  }
  relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_relative_path()) {
    relative_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_relative_path(), 
      GetArena());
  }
  ::memcpy(&playlist_id_, &from.playlist_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&clear_first_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_first_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.RequestAppendFiles)
}

void RequestAppendFiles::SharedCtor() {
new_playlist_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&playlist_id_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&clear_first_) -
    reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_first_));
}

RequestAppendFiles::~RequestAppendFiles() {
  // @@protoc_insertion_point(destructor:cpb.remote.RequestAppendFiles)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RequestAppendFiles::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  new_playlist_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  relative_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RequestAppendFiles::ArenaDtor(void* object) {
  RequestAppendFiles* _this = reinterpret_cast< RequestAppendFiles* >(object);
  (void)_this;
}
void RequestAppendFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RequestAppendFiles::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RequestAppendFiles::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.RequestAppendFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  files_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      new_playlist_name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      relative_path_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&playlist_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&clear_first_) -
        reinterpret_cast<char*>(&playlist_id_)) + sizeof(clear_first_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RequestAppendFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 playlist_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_playlist_id(&has_bits);
          playlist_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string new_playlist_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_new_playlist_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestAppendFiles.new_playlist_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string relative_path = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_relative_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestAppendFiles.relative_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string files = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_files();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.RequestAppendFiles.files");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bool play_now = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_play_now(&has_bits);
          play_now_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool clear_first = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_clear_first(&has_bits);
          clear_first_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RequestAppendFiles::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.RequestAppendFiles)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 playlist_id = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_playlist_id(), target);
  }

  // optional string new_playlist_name = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_new_playlist_name().data(), static_cast<int>(this->_internal_new_playlist_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestAppendFiles.new_playlist_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_new_playlist_name(), target);
  }

  // optional string relative_path = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_relative_path().data(), static_cast<int>(this->_internal_relative_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestAppendFiles.relative_path");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_relative_path(), target);
  }

  // repeated string files = 4;
  for (int i = 0, n = this->_internal_files_size(); i < n; i++) {
    const auto& s = this->_internal_files(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.RequestAppendFiles.files");
    target = stream->WriteString(4, s, target);
  }

  // optional bool play_now = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_play_now(), target);
  }

  // optional bool clear_first = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_clear_first(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.RequestAppendFiles)
  return target;
}

size_t RequestAppendFiles::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.RequestAppendFiles)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string files = 4;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(files_.size());
  for (int i = 0, n = files_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      files_.Get(i));
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string new_playlist_name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_new_playlist_name());
    }

    // optional string relative_path = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_relative_path());
    }

    // optional int32 playlist_id = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_playlist_id());
    }

    // optional bool play_now = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool clear_first = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RequestAppendFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.RequestAppendFiles)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestAppendFiles* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestAppendFiles>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.RequestAppendFiles)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.RequestAppendFiles)
    MergeFrom(*source);
  }
}

void RequestAppendFiles::MergeFrom(const RequestAppendFiles& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.RequestAppendFiles)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  files_.MergeFrom(from.files_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_new_playlist_name(from._internal_new_playlist_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_relative_path(from._internal_relative_path());
    }
    if (cached_has_bits & 0x00000004u) {
      playlist_id_ = from.playlist_id_;
    }
    if (cached_has_bits & 0x00000008u) {
      play_now_ = from.play_now_;
    }
    if (cached_has_bits & 0x00000010u) {
      clear_first_ = from.clear_first_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RequestAppendFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.RequestAppendFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestAppendFiles::CopyFrom(const RequestAppendFiles& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.RequestAppendFiles)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestAppendFiles::IsInitialized() const {
  return true;
}

void RequestAppendFiles::InternalSwap(RequestAppendFiles* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  files_.InternalSwap(&other->files_);
  new_playlist_name_.Swap(&other->new_playlist_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  relative_path_.Swap(&other->relative_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestAppendFiles, clear_first_)
      + sizeof(RequestAppendFiles::clear_first_)
      - PROTOBUF_FIELD_OFFSET(RequestAppendFiles, playlist_id_)>(
          reinterpret_cast<char*>(&playlist_id_),
          reinterpret_cast<char*>(&other->playlist_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RequestAppendFiles::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[38]);
}

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

class Stream::_Internal {
 public:
  using HasBits = decltype(std::declval<Stream>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_url(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_url_logo(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

Stream::Stream(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Stream)
}
Stream::Stream(const Stream& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArena());
  }
  url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_url()) {
    url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_url(), 
      GetArena());
  }
  url_logo_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_url_logo()) {
    url_logo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_url_logo(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Stream)
}

void Stream::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
url_logo_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Stream::~Stream() {
  // @@protoc_insertion_point(destructor:cpb.remote.Stream)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Stream::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  url_logo_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Stream::ArenaDtor(void* object) {
  Stream* _this = reinterpret_cast< Stream* >(object);
  (void)_this;
}
void Stream::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Stream::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Stream::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Stream)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      url_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      url_logo_.ClearNonDefaultToEmpty();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Stream::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Stream.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string url = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_url();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Stream.url");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string url_logo = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_url_logo();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "cpb.remote.Stream.url_logo");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Stream::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Stream)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Stream.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // optional string url = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Stream.url");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_url(), target);
  }

  // optional string url_logo = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_url_logo().data(), static_cast<int>(this->_internal_url_logo().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "cpb.remote.Stream.url_logo");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_url_logo(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Stream)
  return target;
}

size_t Stream::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Stream)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional string url = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_url());
    }

    // optional string url_logo = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_url_logo());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Stream::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Stream)
  GOOGLE_DCHECK_NE(&from, this);
  const Stream* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Stream>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Stream)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Stream)
    MergeFrom(*source);
  }
}

void Stream::MergeFrom(const Stream& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Stream)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_url(from._internal_url());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_url_logo(from._internal_url_logo());
    }
  }
}

void Stream::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Stream)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Stream::CopyFrom(const Stream& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Stream)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Stream::IsInitialized() const {
  return true;
}

void Stream::InternalSwap(Stream* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  url_logo_.Swap(&other->url_logo_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata Stream::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[39]);
}

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

class ResponseSavedRadios::_Internal {
 public:
};

ResponseSavedRadios::ResponseSavedRadios(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  streams_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.ResponseSavedRadios)
}
ResponseSavedRadios::ResponseSavedRadios(const ResponseSavedRadios& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      streams_(from.streams_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:cpb.remote.ResponseSavedRadios)
}

void ResponseSavedRadios::SharedCtor() {
}

ResponseSavedRadios::~ResponseSavedRadios() {
  // @@protoc_insertion_point(destructor:cpb.remote.ResponseSavedRadios)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void ResponseSavedRadios::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ResponseSavedRadios::ArenaDtor(void* object) {
  ResponseSavedRadios* _this = reinterpret_cast< ResponseSavedRadios* >(object);
  (void)_this;
}
void ResponseSavedRadios::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ResponseSavedRadios::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ResponseSavedRadios::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.ResponseSavedRadios)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  streams_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ResponseSavedRadios::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .cpb.remote.Stream streams = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_streams(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ResponseSavedRadios::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.ResponseSavedRadios)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .cpb.remote.Stream streams = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_streams_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_streams(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.ResponseSavedRadios)
  return target;
}

size_t ResponseSavedRadios::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.ResponseSavedRadios)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .cpb.remote.Stream streams = 1;
  total_size += 1UL * this->_internal_streams_size();
  for (const auto& msg : this->streams_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ResponseSavedRadios::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.ResponseSavedRadios)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseSavedRadios* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseSavedRadios>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.ResponseSavedRadios)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.ResponseSavedRadios)
    MergeFrom(*source);
  }
}

void ResponseSavedRadios::MergeFrom(const ResponseSavedRadios& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.ResponseSavedRadios)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  streams_.MergeFrom(from.streams_);
}

void ResponseSavedRadios::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.ResponseSavedRadios)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseSavedRadios::CopyFrom(const ResponseSavedRadios& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.ResponseSavedRadios)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseSavedRadios::IsInitialized() const {
  return true;
}

void ResponseSavedRadios::InternalSwap(ResponseSavedRadios* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  streams_.InternalSwap(&other->streams_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ResponseSavedRadios::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[40]);
}

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

class Message::_Internal {
 public:
  using HasBits = decltype(std::declval<Message>()._has_bits_);
  static void set_has_version(HasBits* has_bits) {
    (*has_bits)[1] |= 32u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[1] |= 16u;
  }
  static const ::cpb::remote::RequestConnect& request_connect(const Message* msg);
  static void set_has_request_connect(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static const ::cpb::remote::RequestPlaylists& request_playlists(const Message* msg);
  static void set_has_request_playlists(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
  static const ::cpb::remote::RequestPlaylistSongs& request_playlist_songs(const Message* msg);
  static void set_has_request_playlist_songs(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::cpb::remote::RequestChangeSong& request_change_song(const Message* msg);
  static void set_has_request_change_song(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::cpb::remote::RequestSetVolume& request_set_volume(const Message* msg);
  static void set_has_request_set_volume(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::cpb::remote::RequestSetTrackPosition& request_set_track_position(const Message* msg);
  static void set_has_request_set_track_position(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static const ::cpb::remote::RequestInsertUrls& request_insert_urls(const Message* msg);
  static void set_has_request_insert_urls(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static const ::cpb::remote::RequestRemoveSongs& request_remove_songs(const Message* msg);
  static void set_has_request_remove_songs(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static const ::cpb::remote::RequestOpenPlaylist& request_open_playlist(const Message* msg);
  static void set_has_request_open_playlist(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static const ::cpb::remote::RequestClosePlaylist& request_close_playlist(const Message* msg);
  static void set_has_request_close_playlist(HasBits* has_bits) {
    (*has_bits)[0] |= 524288u;
  }
  static const ::cpb::remote::RequestUpdatePlaylist& request_update_playlist(const Message* msg);
  static void set_has_request_update_playlist(HasBits* has_bits) {
    (*has_bits)[1] |= 4u;
  }
  static const ::cpb::remote::RequestDownloadSongs& request_download_songs(const Message* msg);
  static void set_has_request_download_songs(HasBits* has_bits) {
    (*has_bits)[0] |= 2097152u;
  }
  static const ::cpb::remote::RequestRateSong& request_rate_song(const Message* msg);
  static void set_has_request_rate_song(HasBits* has_bits) {
    (*has_bits)[0] |= 33554432u;
  }
  static const ::cpb::remote::RequestGlobalSearch& request_global_search(const Message* msg);
  static void set_has_request_global_search(HasBits* has_bits) {
    (*has_bits)[0] |= 134217728u;
  }
  static const ::cpb::remote::RequestListFiles& request_list_files(const Message* msg);
  static void set_has_request_list_files(HasBits* has_bits) {
    (*has_bits)[0] |= 2147483648u;
  }
  static const ::cpb::remote::RequestAppendFiles& request_append_files(const Message* msg);
  static void set_has_request_append_files(HasBits* has_bits) {
    (*has_bits)[1] |= 1u;
  }
  static const ::cpb::remote::Repeat& repeat(const Message* msg);
  static void set_has_repeat(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::cpb::remote::Shuffle& shuffle(const Message* msg);
  static void set_has_shuffle(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::cpb::remote::ResponseClementineInfo& response_clementine_info(const Message* msg);
  static void set_has_response_clementine_info(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::cpb::remote::ResponseCurrentMetadata& response_current_metadata(const Message* msg);
  static void set_has_response_current_metadata(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::cpb::remote::ResponsePlaylists& response_playlists(const Message* msg);
  static void set_has_response_playlists(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::cpb::remote::ResponsePlaylistSongs& response_playlist_songs(const Message* msg);
  static void set_has_response_playlist_songs(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static const ::cpb::remote::ResponseEngineStateChanged& response_engine_state_changed(const Message* msg);
  static void set_has_response_engine_state_changed(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static const ::cpb::remote::ResponseUpdateTrackPosition& response_update_track_position(const Message* msg);
  static void set_has_response_update_track_position(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static const ::cpb::remote::ResponseDisconnect& response_disconnect(const Message* msg);
  static void set_has_response_disconnect(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static const ::cpb::remote::ResponseActiveChanged& response_active_changed(const Message* msg);
  static void set_has_response_active_changed(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static const ::cpb::remote::ResponseLyrics& response_lyrics(const Message* msg);
  static void set_has_response_lyrics(HasBits* has_bits) {
    (*has_bits)[0] |= 1048576u;
  }
  static const ::cpb::remote::ResponseSongFileChunk& response_song_file_chunk(const Message* msg);
  static void set_has_response_song_file_chunk(HasBits* has_bits) {
    (*has_bits)[0] |= 4194304u;
  }
  static const ::cpb::remote::ResponseSongOffer& response_song_offer(const Message* msg);
  static void set_has_response_song_offer(HasBits* has_bits) {
    (*has_bits)[0] |= 8388608u;
  }
  static const ::cpb::remote::ResponseLibraryChunk& response_library_chunk(const Message* msg);
  static void set_has_response_library_chunk(HasBits* has_bits) {
    (*has_bits)[0] |= 16777216u;
  }
  static const ::cpb::remote::ResponseDownloadTotalSize& response_download_total_size(const Message* msg);
  static void set_has_response_download_total_size(HasBits* has_bits) {
    (*has_bits)[0] |= 67108864u;
  }
  static const ::cpb::remote::ResponseGlobalSearch& response_global_search(const Message* msg);
  static void set_has_response_global_search(HasBits* has_bits) {
    (*has_bits)[0] |= 268435456u;
  }
  static const ::cpb::remote::ResponseTranscoderStatus& response_transcoder_status(const Message* msg);
  static void set_has_response_transcoder_status(HasBits* has_bits) {
    (*has_bits)[0] |= 536870912u;
  }
  static const ::cpb::remote::ResponseGlobalSearchStatus& response_global_search_status(const Message* msg);
  static void set_has_response_global_search_status(HasBits* has_bits) {
    (*has_bits)[0] |= 1073741824u;
  }
  static const ::cpb::remote::ResponseListFiles& response_list_files(const Message* msg);
  static void set_has_response_list_files(HasBits* has_bits) {
    (*has_bits)[1] |= 2u;
  }
  static const ::cpb::remote::ResponseSavedRadios& response_saved_radios(const Message* msg);
  static void set_has_response_saved_radios(HasBits* has_bits) {
    (*has_bits)[1] |= 8u;
  }
};

const ::cpb::remote::RequestConnect&
Message::_Internal::request_connect(const Message* msg) {
  return *msg->request_connect_;
}
const ::cpb::remote::RequestPlaylists&
Message::_Internal::request_playlists(const Message* msg) {
  return *msg->request_playlists_;
}
const ::cpb::remote::RequestPlaylistSongs&
Message::_Internal::request_playlist_songs(const Message* msg) {
  return *msg->request_playlist_songs_;
}
const ::cpb::remote::RequestChangeSong&
Message::_Internal::request_change_song(const Message* msg) {
  return *msg->request_change_song_;
}
const ::cpb::remote::RequestSetVolume&
Message::_Internal::request_set_volume(const Message* msg) {
  return *msg->request_set_volume_;
}
const ::cpb::remote::RequestSetTrackPosition&
Message::_Internal::request_set_track_position(const Message* msg) {
  return *msg->request_set_track_position_;
}
const ::cpb::remote::RequestInsertUrls&
Message::_Internal::request_insert_urls(const Message* msg) {
  return *msg->request_insert_urls_;
}
const ::cpb::remote::RequestRemoveSongs&
Message::_Internal::request_remove_songs(const Message* msg) {
  return *msg->request_remove_songs_;
}
const ::cpb::remote::RequestOpenPlaylist&
Message::_Internal::request_open_playlist(const Message* msg) {
  return *msg->request_open_playlist_;
}
const ::cpb::remote::RequestClosePlaylist&
Message::_Internal::request_close_playlist(const Message* msg) {
  return *msg->request_close_playlist_;
}
const ::cpb::remote::RequestUpdatePlaylist&
Message::_Internal::request_update_playlist(const Message* msg) {
  return *msg->request_update_playlist_;
}
const ::cpb::remote::RequestDownloadSongs&
Message::_Internal::request_download_songs(const Message* msg) {
  return *msg->request_download_songs_;
}
const ::cpb::remote::RequestRateSong&
Message::_Internal::request_rate_song(const Message* msg) {
  return *msg->request_rate_song_;
}
const ::cpb::remote::RequestGlobalSearch&
Message::_Internal::request_global_search(const Message* msg) {
  return *msg->request_global_search_;
}
const ::cpb::remote::RequestListFiles&
Message::_Internal::request_list_files(const Message* msg) {
  return *msg->request_list_files_;
}
const ::cpb::remote::RequestAppendFiles&
Message::_Internal::request_append_files(const Message* msg) {
  return *msg->request_append_files_;
}
const ::cpb::remote::Repeat&
Message::_Internal::repeat(const Message* msg) {
  return *msg->repeat_;
}
const ::cpb::remote::Shuffle&
Message::_Internal::shuffle(const Message* msg) {
  return *msg->shuffle_;
}
const ::cpb::remote::ResponseClementineInfo&
Message::_Internal::response_clementine_info(const Message* msg) {
  return *msg->response_clementine_info_;
}
const ::cpb::remote::ResponseCurrentMetadata&
Message::_Internal::response_current_metadata(const Message* msg) {
  return *msg->response_current_metadata_;
}
const ::cpb::remote::ResponsePlaylists&
Message::_Internal::response_playlists(const Message* msg) {
  return *msg->response_playlists_;
}
const ::cpb::remote::ResponsePlaylistSongs&
Message::_Internal::response_playlist_songs(const Message* msg) {
  return *msg->response_playlist_songs_;
}
const ::cpb::remote::ResponseEngineStateChanged&
Message::_Internal::response_engine_state_changed(const Message* msg) {
  return *msg->response_engine_state_changed_;
}
const ::cpb::remote::ResponseUpdateTrackPosition&
Message::_Internal::response_update_track_position(const Message* msg) {
  return *msg->response_update_track_position_;
}
const ::cpb::remote::ResponseDisconnect&
Message::_Internal::response_disconnect(const Message* msg) {
  return *msg->response_disconnect_;
}
const ::cpb::remote::ResponseActiveChanged&
Message::_Internal::response_active_changed(const Message* msg) {
  return *msg->response_active_changed_;
}
const ::cpb::remote::ResponseLyrics&
Message::_Internal::response_lyrics(const Message* msg) {
  return *msg->response_lyrics_;
}
const ::cpb::remote::ResponseSongFileChunk&
Message::_Internal::response_song_file_chunk(const Message* msg) {
  return *msg->response_song_file_chunk_;
}
const ::cpb::remote::ResponseSongOffer&
Message::_Internal::response_song_offer(const Message* msg) {
  return *msg->response_song_offer_;
}
const ::cpb::remote::ResponseLibraryChunk&
Message::_Internal::response_library_chunk(const Message* msg) {
  return *msg->response_library_chunk_;
}
const ::cpb::remote::ResponseDownloadTotalSize&
Message::_Internal::response_download_total_size(const Message* msg) {
  return *msg->response_download_total_size_;
}
const ::cpb::remote::ResponseGlobalSearch&
Message::_Internal::response_global_search(const Message* msg) {
  return *msg->response_global_search_;
}
const ::cpb::remote::ResponseTranscoderStatus&
Message::_Internal::response_transcoder_status(const Message* msg) {
  return *msg->response_transcoder_status_;
}
const ::cpb::remote::ResponseGlobalSearchStatus&
Message::_Internal::response_global_search_status(const Message* msg) {
  return *msg->response_global_search_status_;
}
const ::cpb::remote::ResponseListFiles&
Message::_Internal::response_list_files(const Message* msg) {
  return *msg->response_list_files_;
}
const ::cpb::remote::ResponseSavedRadios&
Message::_Internal::response_saved_radios(const Message* msg) {
  return *msg->response_saved_radios_;
}
Message::Message(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:cpb.remote.Message)
}
Message::Message(const Message& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_request_playlist_songs()) {
    request_playlist_songs_ = new ::cpb::remote::RequestPlaylistSongs(*from.request_playlist_songs_);
  } else {
    request_playlist_songs_ = nullptr;
  }
  if (from._internal_has_request_change_song()) {
    request_change_song_ = new ::cpb::remote::RequestChangeSong(*from.request_change_song_);
  } else {
    request_change_song_ = nullptr;
  }
  if (from._internal_has_request_set_volume()) {
    request_set_volume_ = new ::cpb::remote::RequestSetVolume(*from.request_set_volume_);
  } else {
    request_set_volume_ = nullptr;
  }
  if (from._internal_has_repeat()) {
    repeat_ = new ::cpb::remote::Repeat(*from.repeat_);
  } else {
    repeat_ = nullptr;
  }
  if (from._internal_has_shuffle()) {
    shuffle_ = new ::cpb::remote::Shuffle(*from.shuffle_);
  } else {
    shuffle_ = nullptr;
  }
  if (from._internal_has_response_clementine_info()) {
    response_clementine_info_ = new ::cpb::remote::ResponseClementineInfo(*from.response_clementine_info_);
  } else {
    response_clementine_info_ = nullptr;
  }
  if (from._internal_has_response_current_metadata()) {
    response_current_metadata_ = new ::cpb::remote::ResponseCurrentMetadata(*from.response_current_metadata_);
  } else {
    response_current_metadata_ = nullptr;
  }
  if (from._internal_has_response_playlists()) {
    response_playlists_ = new ::cpb::remote::ResponsePlaylists(*from.response_playlists_);
  } else {
    response_playlists_ = nullptr;
  }
  if (from._internal_has_response_playlist_songs()) {
    response_playlist_songs_ = new ::cpb::remote::ResponsePlaylistSongs(*from.response_playlist_songs_);
  } else {
    response_playlist_songs_ = nullptr;
  }
  if (from._internal_has_response_engine_state_changed()) {
    response_engine_state_changed_ = new ::cpb::remote::ResponseEngineStateChanged(*from.response_engine_state_changed_);
  } else {
    response_engine_state_changed_ = nullptr;
  }
  if (from._internal_has_response_update_track_position()) {
    response_update_track_position_ = new ::cpb::remote::ResponseUpdateTrackPosition(*from.response_update_track_position_);
  } else {
    response_update_track_position_ = nullptr;
  }
  if (from._internal_has_request_connect()) {
    request_connect_ = new ::cpb::remote::RequestConnect(*from.request_connect_);
  } else {
    request_connect_ = nullptr;
  }
  if (from._internal_has_response_disconnect()) {
    response_disconnect_ = new ::cpb::remote::ResponseDisconnect(*from.response_disconnect_);
  } else {
    response_disconnect_ = nullptr;
  }
  if (from._internal_has_request_set_track_position()) {
    request_set_track_position_ = new ::cpb::remote::RequestSetTrackPosition(*from.request_set_track_position_);
  } else {
    request_set_track_position_ = nullptr;
  }
  if (from._internal_has_response_active_changed()) {
    response_active_changed_ = new ::cpb::remote::ResponseActiveChanged(*from.response_active_changed_);
  } else {
    response_active_changed_ = nullptr;
  }
  if (from._internal_has_request_insert_urls()) {
    request_insert_urls_ = new ::cpb::remote::RequestInsertUrls(*from.request_insert_urls_);
  } else {
    request_insert_urls_ = nullptr;
  }
  if (from._internal_has_request_remove_songs()) {
    request_remove_songs_ = new ::cpb::remote::RequestRemoveSongs(*from.request_remove_songs_);
  } else {
    request_remove_songs_ = nullptr;
  }
  if (from._internal_has_request_playlists()) {
    request_playlists_ = new ::cpb::remote::RequestPlaylists(*from.request_playlists_);
  } else {
    request_playlists_ = nullptr;
  }
  if (from._internal_has_request_open_playlist()) {
    request_open_playlist_ = new ::cpb::remote::RequestOpenPlaylist(*from.request_open_playlist_);
  } else {
    request_open_playlist_ = nullptr;
  }
  if (from._internal_has_request_close_playlist()) {
    request_close_playlist_ = new ::cpb::remote::RequestClosePlaylist(*from.request_close_playlist_);
  } else {
    request_close_playlist_ = nullptr;
  }
  if (from._internal_has_response_lyrics()) {
    response_lyrics_ = new ::cpb::remote::ResponseLyrics(*from.response_lyrics_);
  } else {
    response_lyrics_ = nullptr;
  }
  if (from._internal_has_request_download_songs()) {
    request_download_songs_ = new ::cpb::remote::RequestDownloadSongs(*from.request_download_songs_);
  } else {
    request_download_songs_ = nullptr;
  }
  if (from._internal_has_response_song_file_chunk()) {
    response_song_file_chunk_ = new ::cpb::remote::ResponseSongFileChunk(*from.response_song_file_chunk_);
  } else {
    response_song_file_chunk_ = nullptr;
  }
  if (from._internal_has_response_song_offer()) {
    response_song_offer_ = new ::cpb::remote::ResponseSongOffer(*from.response_song_offer_);
  } else {
    response_song_offer_ = nullptr;
  }
  if (from._internal_has_response_library_chunk()) {
    response_library_chunk_ = new ::cpb::remote::ResponseLibraryChunk(*from.response_library_chunk_);
  } else {
    response_library_chunk_ = nullptr;
  }
  if (from._internal_has_request_rate_song()) {
    request_rate_song_ = new ::cpb::remote::RequestRateSong(*from.request_rate_song_);
  } else {
    request_rate_song_ = nullptr;
  }
  if (from._internal_has_response_download_total_size()) {
    response_download_total_size_ = new ::cpb::remote::ResponseDownloadTotalSize(*from.response_download_total_size_);
  } else {
    response_download_total_size_ = nullptr;
  }
  if (from._internal_has_request_global_search()) {
    request_global_search_ = new ::cpb::remote::RequestGlobalSearch(*from.request_global_search_);
  } else {
    request_global_search_ = nullptr;
  }
  if (from._internal_has_response_global_search()) {
    response_global_search_ = new ::cpb::remote::ResponseGlobalSearch(*from.response_global_search_);
  } else {
    response_global_search_ = nullptr;
  }
  if (from._internal_has_response_transcoder_status()) {
    response_transcoder_status_ = new ::cpb::remote::ResponseTranscoderStatus(*from.response_transcoder_status_);
  } else {
    response_transcoder_status_ = nullptr;
  }
  if (from._internal_has_response_global_search_status()) {
    response_global_search_status_ = new ::cpb::remote::ResponseGlobalSearchStatus(*from.response_global_search_status_);
  } else {
    response_global_search_status_ = nullptr;
  }
  if (from._internal_has_request_list_files()) {
    request_list_files_ = new ::cpb::remote::RequestListFiles(*from.request_list_files_);
  } else {
    request_list_files_ = nullptr;
  }
  if (from._internal_has_request_append_files()) {
    request_append_files_ = new ::cpb::remote::RequestAppendFiles(*from.request_append_files_);
  } else {
    request_append_files_ = nullptr;
  }
  if (from._internal_has_response_list_files()) {
    response_list_files_ = new ::cpb::remote::ResponseListFiles(*from.response_list_files_);
  } else {
    response_list_files_ = nullptr;
  }
  if (from._internal_has_request_update_playlist()) {
    request_update_playlist_ = new ::cpb::remote::RequestUpdatePlaylist(*from.request_update_playlist_);
  } else {
    request_update_playlist_ = nullptr;
  }
  if (from._internal_has_response_saved_radios()) {
    response_saved_radios_ = new ::cpb::remote::ResponseSavedRadios(*from.response_saved_radios_);
  } else {
    response_saved_radios_ = nullptr;
  }
  ::memcpy(&type_, &from.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&version_) -
    reinterpret_cast<char*>(&type_)) + sizeof(version_));
  // @@protoc_insertion_point(copy_constructor:cpb.remote.Message)
}

void Message::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&request_playlist_songs_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&request_playlist_songs_)) + sizeof(type_));
version_ = 21;
}

Message::~Message() {
  // @@protoc_insertion_point(destructor:cpb.remote.Message)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Message::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete request_playlist_songs_;
  if (this != internal_default_instance()) delete request_change_song_;
  if (this != internal_default_instance()) delete request_set_volume_;
  if (this != internal_default_instance()) delete repeat_;
  if (this != internal_default_instance()) delete shuffle_;
  if (this != internal_default_instance()) delete response_clementine_info_;
  if (this != internal_default_instance()) delete response_current_metadata_;
  if (this != internal_default_instance()) delete response_playlists_;
  if (this != internal_default_instance()) delete response_playlist_songs_;
  if (this != internal_default_instance()) delete response_engine_state_changed_;
  if (this != internal_default_instance()) delete response_update_track_position_;
  if (this != internal_default_instance()) delete request_connect_;
  if (this != internal_default_instance()) delete response_disconnect_;
  if (this != internal_default_instance()) delete request_set_track_position_;
  if (this != internal_default_instance()) delete response_active_changed_;
  if (this != internal_default_instance()) delete request_insert_urls_;
  if (this != internal_default_instance()) delete request_remove_songs_;
  if (this != internal_default_instance()) delete request_playlists_;
  if (this != internal_default_instance()) delete request_open_playlist_;
  if (this != internal_default_instance()) delete request_close_playlist_;
  if (this != internal_default_instance()) delete response_lyrics_;
  if (this != internal_default_instance()) delete request_download_songs_;
  if (this != internal_default_instance()) delete response_song_file_chunk_;
  if (this != internal_default_instance()) delete response_song_offer_;
  if (this != internal_default_instance()) delete response_library_chunk_;
  if (this != internal_default_instance()) delete request_rate_song_;
  if (this != internal_default_instance()) delete response_download_total_size_;
  if (this != internal_default_instance()) delete request_global_search_;
  if (this != internal_default_instance()) delete response_global_search_;
  if (this != internal_default_instance()) delete response_transcoder_status_;
  if (this != internal_default_instance()) delete response_global_search_status_;
  if (this != internal_default_instance()) delete request_list_files_;
  if (this != internal_default_instance()) delete request_append_files_;
  if (this != internal_default_instance()) delete response_list_files_;
  if (this != internal_default_instance()) delete request_update_playlist_;
  if (this != internal_default_instance()) delete response_saved_radios_;
}

void Message::ArenaDtor(void* object) {
  Message* _this = reinterpret_cast< Message* >(object);
  (void)_this;
}
void Message::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Message::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Message::Clear() {
// @@protoc_insertion_point(message_clear_start:cpb.remote.Message)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(request_playlist_songs_ != nullptr);
      request_playlist_songs_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(request_change_song_ != nullptr);
      request_change_song_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(request_set_volume_ != nullptr);
      request_set_volume_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(repeat_ != nullptr);
      repeat_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(shuffle_ != nullptr);
      shuffle_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(response_clementine_info_ != nullptr);
      response_clementine_info_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(response_current_metadata_ != nullptr);
      response_current_metadata_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(response_playlists_ != nullptr);
      response_playlists_->Clear();
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(response_playlist_songs_ != nullptr);
      response_playlist_songs_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(response_engine_state_changed_ != nullptr);
      response_engine_state_changed_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(response_update_track_position_ != nullptr);
      response_update_track_position_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(request_connect_ != nullptr);
      request_connect_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(response_disconnect_ != nullptr);
      response_disconnect_->Clear();
    }
    if (cached_has_bits & 0x00002000u) {
      GOOGLE_DCHECK(request_set_track_position_ != nullptr);
      request_set_track_position_->Clear();
    }
    if (cached_has_bits & 0x00004000u) {
      GOOGLE_DCHECK(response_active_changed_ != nullptr);
      response_active_changed_->Clear();
    }
    if (cached_has_bits & 0x00008000u) {
      GOOGLE_DCHECK(request_insert_urls_ != nullptr);
      request_insert_urls_->Clear();
    }
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      GOOGLE_DCHECK(request_remove_songs_ != nullptr);
      request_remove_songs_->Clear();
    }
    if (cached_has_bits & 0x00020000u) {
      GOOGLE_DCHECK(request_playlists_ != nullptr);
      request_playlists_->Clear();
    }
    if (cached_has_bits & 0x00040000u) {
      GOOGLE_DCHECK(request_open_playlist_ != nullptr);
      request_open_playlist_->Clear();
    }
    if (cached_has_bits & 0x00080000u) {
      GOOGLE_DCHECK(request_close_playlist_ != nullptr);
      request_close_playlist_->Clear();
    }
    if (cached_has_bits & 0x00100000u) {
      GOOGLE_DCHECK(response_lyrics_ != nullptr);
      response_lyrics_->Clear();
    }
    if (cached_has_bits & 0x00200000u) {
      GOOGLE_DCHECK(request_download_songs_ != nullptr);
      request_download_songs_->Clear();
    }
    if (cached_has_bits & 0x00400000u) {
      GOOGLE_DCHECK(response_song_file_chunk_ != nullptr);
      response_song_file_chunk_->Clear();
    }
    if (cached_has_bits & 0x00800000u) {
      GOOGLE_DCHECK(response_song_offer_ != nullptr);
      response_song_offer_->Clear();
    }
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      GOOGLE_DCHECK(response_library_chunk_ != nullptr);
      response_library_chunk_->Clear();
    }
    if (cached_has_bits & 0x02000000u) {
      GOOGLE_DCHECK(request_rate_song_ != nullptr);
      request_rate_song_->Clear();
    }
    if (cached_has_bits & 0x04000000u) {
      GOOGLE_DCHECK(response_download_total_size_ != nullptr);
      response_download_total_size_->Clear();
    }
    if (cached_has_bits & 0x08000000u) {
      GOOGLE_DCHECK(request_global_search_ != nullptr);
      request_global_search_->Clear();
    }
    if (cached_has_bits & 0x10000000u) {
      GOOGLE_DCHECK(response_global_search_ != nullptr);
      response_global_search_->Clear();
    }
    if (cached_has_bits & 0x20000000u) {
      GOOGLE_DCHECK(response_transcoder_status_ != nullptr);
      response_transcoder_status_->Clear();
    }
    if (cached_has_bits & 0x40000000u) {
      GOOGLE_DCHECK(response_global_search_status_ != nullptr);
      response_global_search_status_->Clear();
    }
    if (cached_has_bits & 0x80000000u) {
      GOOGLE_DCHECK(request_list_files_ != nullptr);
      request_list_files_->Clear();
    }
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(request_append_files_ != nullptr);
      request_append_files_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(response_list_files_ != nullptr);
      response_list_files_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(request_update_playlist_ != nullptr);
      request_update_playlist_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(response_saved_radios_ != nullptr);
      response_saved_radios_->Clear();
    }
  }
  if (cached_has_bits & 0x00000030u) {
    type_ = 0;
    version_ = 21;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Message::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 version = 1 [default = 21];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_version(&_has_bits_);
          version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.MsgType type = 2 [default = UNKNOWN];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::cpb::remote::MsgType_IsValid(val))) {
            _internal_set_type(static_cast<::cpb::remote::MsgType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestPlaylistSongs request_playlist_songs = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_playlist_songs(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestChangeSong request_change_song = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_change_song(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestSetVolume request_set_volume = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_set_volume(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.Repeat repeat = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_repeat(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.Shuffle shuffle = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_shuffle(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseClementineInfo response_clementine_info = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_clementine_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseCurrentMetadata response_current_metadata = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_current_metadata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponsePlaylists response_playlists = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_playlists(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponsePlaylistSongs response_playlist_songs = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_playlist_songs(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseEngineStateChanged response_engine_state_changed = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_engine_state_changed(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseUpdateTrackPosition response_update_track_position = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_update_track_position(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestConnect request_connect = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_connect(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseDisconnect response_disconnect = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_disconnect(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestSetTrackPosition request_set_track_position = 23;
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_set_track_position(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseActiveChanged response_active_changed = 24;
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_active_changed(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestInsertUrls request_insert_urls = 25;
      case 25:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_insert_urls(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestRemoveSongs request_remove_songs = 26;
      case 26:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_remove_songs(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestPlaylists request_playlists = 27;
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_playlists(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestOpenPlaylist request_open_playlist = 28;
      case 28:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_open_playlist(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestClosePlaylist request_close_playlist = 29;
      case 29:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_close_playlist(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseLyrics response_lyrics = 30;
      case 30:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_lyrics(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestDownloadSongs request_download_songs = 31;
      case 31:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_download_songs(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseSongFileChunk response_song_file_chunk = 32;
      case 32:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_song_file_chunk(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseSongOffer response_song_offer = 33;
      case 33:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_song_offer(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseLibraryChunk response_library_chunk = 34;
      case 34:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_library_chunk(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestRateSong request_rate_song = 35;
      case 35:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_rate_song(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseDownloadTotalSize response_download_total_size = 36;
      case 36:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_download_total_size(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestGlobalSearch request_global_search = 37;
      case 37:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_global_search(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseGlobalSearch response_global_search = 38;
      case 38:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_global_search(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseTranscoderStatus response_transcoder_status = 39;
      case 39:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_transcoder_status(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseGlobalSearchStatus response_global_search_status = 40;
      case 40:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_global_search_status(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestListFiles request_list_files = 50;
      case 50:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_list_files(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestAppendFiles request_append_files = 51;
      case 51:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_append_files(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseListFiles response_list_files = 52;
      case 52:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_list_files(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.RequestUpdatePlaylist request_update_playlist = 53;
      case 53:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_request_update_playlist(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .cpb.remote.ResponseSavedRadios response_saved_radios = 54;
      case 54:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_response_saved_radios(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Message::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:cpb.remote.Message)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[1];
  // optional int32 version = 1 [default = 21];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_version(), target);
  }

  // optional .cpb.remote.MsgType type = 2 [default = UNKNOWN];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_type(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional .cpb.remote.RequestPlaylistSongs request_playlist_songs = 10;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::request_playlist_songs(this), target, stream);
  }

  // optional .cpb.remote.RequestChangeSong request_change_song = 11;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::request_change_song(this), target, stream);
  }

  // optional .cpb.remote.RequestSetVolume request_set_volume = 12;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::request_set_volume(this), target, stream);
  }

  // optional .cpb.remote.Repeat repeat = 13;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        13, _Internal::repeat(this), target, stream);
  }

  // optional .cpb.remote.Shuffle shuffle = 14;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        14, _Internal::shuffle(this), target, stream);
  }

  // optional .cpb.remote.ResponseClementineInfo response_clementine_info = 15;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        15, _Internal::response_clementine_info(this), target, stream);
  }

  // optional .cpb.remote.ResponseCurrentMetadata response_current_metadata = 16;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        16, _Internal::response_current_metadata(this), target, stream);
  }

  // optional .cpb.remote.ResponsePlaylists response_playlists = 17;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        17, _Internal::response_playlists(this), target, stream);
  }

  // optional .cpb.remote.ResponsePlaylistSongs response_playlist_songs = 18;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        18, _Internal::response_playlist_songs(this), target, stream);
  }

  // optional .cpb.remote.ResponseEngineStateChanged response_engine_state_changed = 19;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        19, _Internal::response_engine_state_changed(this), target, stream);
  }

  // optional .cpb.remote.ResponseUpdateTrackPosition response_update_track_position = 20;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::response_update_track_position(this), target, stream);
  }

  // optional .cpb.remote.RequestConnect request_connect = 21;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        21, _Internal::request_connect(this), target, stream);
  }

  // optional .cpb.remote.ResponseDisconnect response_disconnect = 22;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        22, _Internal::response_disconnect(this), target, stream);
  }

  // optional .cpb.remote.RequestSetTrackPosition request_set_track_position = 23;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        23, _Internal::request_set_track_position(this), target, stream);
  }

  // optional .cpb.remote.ResponseActiveChanged response_active_changed = 24;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        24, _Internal::response_active_changed(this), target, stream);
  }

  // optional .cpb.remote.RequestInsertUrls request_insert_urls = 25;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        25, _Internal::request_insert_urls(this), target, stream);
  }

  // optional .cpb.remote.RequestRemoveSongs request_remove_songs = 26;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        26, _Internal::request_remove_songs(this), target, stream);
  }

  // optional .cpb.remote.RequestPlaylists request_playlists = 27;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        27, _Internal::request_playlists(this), target, stream);
  }

  // optional .cpb.remote.RequestOpenPlaylist request_open_playlist = 28;
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        28, _Internal::request_open_playlist(this), target, stream);
  }

  // optional .cpb.remote.RequestClosePlaylist request_close_playlist = 29;
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        29, _Internal::request_close_playlist(this), target, stream);
  }

  // optional .cpb.remote.ResponseLyrics response_lyrics = 30;
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        30, _Internal::response_lyrics(this), target, stream);
  }

  // optional .cpb.remote.RequestDownloadSongs request_download_songs = 31;
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        31, _Internal::request_download_songs(this), target, stream);
  }

  // optional .cpb.remote.ResponseSongFileChunk response_song_file_chunk = 32;
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        32, _Internal::response_song_file_chunk(this), target, stream);
  }

  // optional .cpb.remote.ResponseSongOffer response_song_offer = 33;
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        33, _Internal::response_song_offer(this), target, stream);
  }

  // optional .cpb.remote.ResponseLibraryChunk response_library_chunk = 34;
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        34, _Internal::response_library_chunk(this), target, stream);
  }

  // optional .cpb.remote.RequestRateSong request_rate_song = 35;
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        35, _Internal::request_rate_song(this), target, stream);
  }

  // optional .cpb.remote.ResponseDownloadTotalSize response_download_total_size = 36;
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        36, _Internal::response_download_total_size(this), target, stream);
  }

  // optional .cpb.remote.RequestGlobalSearch request_global_search = 37;
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        37, _Internal::request_global_search(this), target, stream);
  }

  // optional .cpb.remote.ResponseGlobalSearch response_global_search = 38;
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        38, _Internal::response_global_search(this), target, stream);
  }

  // optional .cpb.remote.ResponseTranscoderStatus response_transcoder_status = 39;
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        39, _Internal::response_transcoder_status(this), target, stream);
  }

  // optional .cpb.remote.ResponseGlobalSearchStatus response_global_search_status = 40;
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        40, _Internal::response_global_search_status(this), target, stream);
  }

  // optional .cpb.remote.RequestListFiles request_list_files = 50;
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        50, _Internal::request_list_files(this), target, stream);
  }

  cached_has_bits = _has_bits_[1];
  // optional .cpb.remote.RequestAppendFiles request_append_files = 51;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        51, _Internal::request_append_files(this), target, stream);
  }

  // optional .cpb.remote.ResponseListFiles response_list_files = 52;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        52, _Internal::response_list_files(this), target, stream);
  }

  // optional .cpb.remote.RequestUpdatePlaylist request_update_playlist = 53;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        53, _Internal::request_update_playlist(this), target, stream);
  }

  // optional .cpb.remote.ResponseSavedRadios response_saved_radios = 54;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        54, _Internal::response_saved_radios(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:cpb.remote.Message)
  return target;
}

size_t Message::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:cpb.remote.Message)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .cpb.remote.RequestPlaylistSongs request_playlist_songs = 10;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_playlist_songs_);
    }

    // optional .cpb.remote.RequestChangeSong request_change_song = 11;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_change_song_);
    }

    // optional .cpb.remote.RequestSetVolume request_set_volume = 12;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_set_volume_);
    }

    // optional .cpb.remote.Repeat repeat = 13;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *repeat_);
    }

    // optional .cpb.remote.Shuffle shuffle = 14;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *shuffle_);
    }

    // optional .cpb.remote.ResponseClementineInfo response_clementine_info = 15;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_clementine_info_);
    }

    // optional .cpb.remote.ResponseCurrentMetadata response_current_metadata = 16;
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_current_metadata_);
    }

    // optional .cpb.remote.ResponsePlaylists response_playlists = 17;
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_playlists_);
    }

  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional .cpb.remote.ResponsePlaylistSongs response_playlist_songs = 18;
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_playlist_songs_);
    }

    // optional .cpb.remote.ResponseEngineStateChanged response_engine_state_changed = 19;
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_engine_state_changed_);
    }

    // optional .cpb.remote.ResponseUpdateTrackPosition response_update_track_position = 20;
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_update_track_position_);
    }

    // optional .cpb.remote.RequestConnect request_connect = 21;
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_connect_);
    }

    // optional .cpb.remote.ResponseDisconnect response_disconnect = 22;
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_disconnect_);
    }

    // optional .cpb.remote.RequestSetTrackPosition request_set_track_position = 23;
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_set_track_position_);
    }

    // optional .cpb.remote.ResponseActiveChanged response_active_changed = 24;
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_active_changed_);
    }

    // optional .cpb.remote.RequestInsertUrls request_insert_urls = 25;
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_insert_urls_);
    }

  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional .cpb.remote.RequestRemoveSongs request_remove_songs = 26;
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_remove_songs_);
    }

    // optional .cpb.remote.RequestPlaylists request_playlists = 27;
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_playlists_);
    }

    // optional .cpb.remote.RequestOpenPlaylist request_open_playlist = 28;
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_open_playlist_);
    }

    // optional .cpb.remote.RequestClosePlaylist request_close_playlist = 29;
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_close_playlist_);
    }

    // optional .cpb.remote.ResponseLyrics response_lyrics = 30;
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_lyrics_);
    }

    // optional .cpb.remote.RequestDownloadSongs request_download_songs = 31;
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_download_songs_);
    }

    // optional .cpb.remote.ResponseSongFileChunk response_song_file_chunk = 32;
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_song_file_chunk_);
    }

    // optional .cpb.remote.ResponseSongOffer response_song_offer = 33;
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_song_offer_);
    }

  }
  if (cached_has_bits & 0xff000000u) {
    // optional .cpb.remote.ResponseLibraryChunk response_library_chunk = 34;
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_library_chunk_);
    }

    // optional .cpb.remote.RequestRateSong request_rate_song = 35;
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_rate_song_);
    }

    // optional .cpb.remote.ResponseDownloadTotalSize response_download_total_size = 36;
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_download_total_size_);
    }

    // optional .cpb.remote.RequestGlobalSearch request_global_search = 37;
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_global_search_);
    }

    // optional .cpb.remote.ResponseGlobalSearch response_global_search = 38;
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_global_search_);
    }

    // optional .cpb.remote.ResponseTranscoderStatus response_transcoder_status = 39;
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_transcoder_status_);
    }

    // optional .cpb.remote.ResponseGlobalSearchStatus response_global_search_status = 40;
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_global_search_status_);
    }

    // optional .cpb.remote.RequestListFiles request_list_files = 50;
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_list_files_);
    }

  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 0x0000003fu) {
    // optional .cpb.remote.RequestAppendFiles request_append_files = 51;
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_append_files_);
    }

    // optional .cpb.remote.ResponseListFiles response_list_files = 52;
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_list_files_);
    }

    // optional .cpb.remote.RequestUpdatePlaylist request_update_playlist = 53;
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_update_playlist_);
    }

    // optional .cpb.remote.ResponseSavedRadios response_saved_radios = 54;
    if (cached_has_bits & 0x00000008u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_saved_radios_);
    }

    // optional .cpb.remote.MsgType type = 2 [default = UNKNOWN];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

    // optional int32 version = 1 [default = 21];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_version());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Message::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:cpb.remote.Message)
  GOOGLE_DCHECK_NE(&from, this);
  const Message* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Message>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:cpb.remote.Message)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:cpb.remote.Message)
    MergeFrom(*source);
  }
}

void Message::MergeFrom(const Message& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cpb.remote.Message)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_request_playlist_songs()->::cpb::remote::RequestPlaylistSongs::MergeFrom(from._internal_request_playlist_songs());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_request_change_song()->::cpb::remote::RequestChangeSong::MergeFrom(from._internal_request_change_song());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_request_set_volume()->::cpb::remote::RequestSetVolume::MergeFrom(from._internal_request_set_volume());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_repeat()->::cpb::remote::Repeat::MergeFrom(from._internal_repeat());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_shuffle()->::cpb::remote::Shuffle::MergeFrom(from._internal_shuffle());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_mutable_response_clementine_info()->::cpb::remote::ResponseClementineInfo::MergeFrom(from._internal_response_clementine_info());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_mutable_response_current_metadata()->::cpb::remote::ResponseCurrentMetadata::MergeFrom(from._internal_response_current_metadata());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_mutable_response_playlists()->::cpb::remote::ResponsePlaylists::MergeFrom(from._internal_response_playlists());
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_mutable_response_playlist_songs()->::cpb::remote::ResponsePlaylistSongs::MergeFrom(from._internal_response_playlist_songs());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_mutable_response_engine_state_changed()->::cpb::remote::ResponseEngineStateChanged::MergeFrom(from._internal_response_engine_state_changed());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_mutable_response_update_track_position()->::cpb::remote::ResponseUpdateTrackPosition::MergeFrom(from._internal_response_update_track_position());
    }
    if (cached_has_bits & 0x00000800u) {
      _internal_mutable_request_connect()->::cpb::remote::RequestConnect::MergeFrom(from._internal_request_connect());
    }
    if (cached_has_bits & 0x00001000u) {
      _internal_mutable_response_disconnect()->::cpb::remote::ResponseDisconnect::MergeFrom(from._internal_response_disconnect());
    }
    if (cached_has_bits & 0x00002000u) {
      _internal_mutable_request_set_track_position()->::cpb::remote::RequestSetTrackPosition::MergeFrom(from._internal_request_set_track_position());
    }
    if (cached_has_bits & 0x00004000u) {
      _internal_mutable_response_active_changed()->::cpb::remote::ResponseActiveChanged::MergeFrom(from._internal_response_active_changed());
    }
    if (cached_has_bits & 0x00008000u) {
      _internal_mutable_request_insert_urls()->::cpb::remote::RequestInsertUrls::MergeFrom(from._internal_request_insert_urls());
    }
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      _internal_mutable_request_remove_songs()->::cpb::remote::RequestRemoveSongs::MergeFrom(from._internal_request_remove_songs());
    }
    if (cached_has_bits & 0x00020000u) {
      _internal_mutable_request_playlists()->::cpb::remote::RequestPlaylists::MergeFrom(from._internal_request_playlists());
    }
    if (cached_has_bits & 0x00040000u) {
      _internal_mutable_request_open_playlist()->::cpb::remote::RequestOpenPlaylist::MergeFrom(from._internal_request_open_playlist());
    }
    if (cached_has_bits & 0x00080000u) {
      _internal_mutable_request_close_playlist()->::cpb::remote::RequestClosePlaylist::MergeFrom(from._internal_request_close_playlist());
    }
    if (cached_has_bits & 0x00100000u) {
      _internal_mutable_response_lyrics()->::cpb::remote::ResponseLyrics::MergeFrom(from._internal_response_lyrics());
    }
    if (cached_has_bits & 0x00200000u) {
      _internal_mutable_request_download_songs()->::cpb::remote::RequestDownloadSongs::MergeFrom(from._internal_request_download_songs());
    }
    if (cached_has_bits & 0x00400000u) {
      _internal_mutable_response_song_file_chunk()->::cpb::remote::ResponseSongFileChunk::MergeFrom(from._internal_response_song_file_chunk());
    }
    if (cached_has_bits & 0x00800000u) {
      _internal_mutable_response_song_offer()->::cpb::remote::ResponseSongOffer::MergeFrom(from._internal_response_song_offer());
    }
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      _internal_mutable_response_library_chunk()->::cpb::remote::ResponseLibraryChunk::MergeFrom(from._internal_response_library_chunk());
    }
    if (cached_has_bits & 0x02000000u) {
      _internal_mutable_request_rate_song()->::cpb::remote::RequestRateSong::MergeFrom(from._internal_request_rate_song());
    }
    if (cached_has_bits & 0x04000000u) {
      _internal_mutable_response_download_total_size()->::cpb::remote::ResponseDownloadTotalSize::MergeFrom(from._internal_response_download_total_size());
    }
    if (cached_has_bits & 0x08000000u) {
      _internal_mutable_request_global_search()->::cpb::remote::RequestGlobalSearch::MergeFrom(from._internal_request_global_search());
    }
    if (cached_has_bits & 0x10000000u) {
      _internal_mutable_response_global_search()->::cpb::remote::ResponseGlobalSearch::MergeFrom(from._internal_response_global_search());
    }
    if (cached_has_bits & 0x20000000u) {
      _internal_mutable_response_transcoder_status()->::cpb::remote::ResponseTranscoderStatus::MergeFrom(from._internal_response_transcoder_status());
    }
    if (cached_has_bits & 0x40000000u) {
      _internal_mutable_response_global_search_status()->::cpb::remote::ResponseGlobalSearchStatus::MergeFrom(from._internal_response_global_search_status());
    }
    if (cached_has_bits & 0x80000000u) {
      _internal_mutable_request_list_files()->::cpb::remote::RequestListFiles::MergeFrom(from._internal_request_list_files());
    }
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_request_append_files()->::cpb::remote::RequestAppendFiles::MergeFrom(from._internal_request_append_files());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_response_list_files()->::cpb::remote::ResponseListFiles::MergeFrom(from._internal_response_list_files());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_request_update_playlist()->::cpb::remote::RequestUpdatePlaylist::MergeFrom(from._internal_request_update_playlist());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_response_saved_radios()->::cpb::remote::ResponseSavedRadios::MergeFrom(from._internal_response_saved_radios());
    }
    if (cached_has_bits & 0x00000010u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000020u) {
      version_ = from.version_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
}

void Message::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:cpb.remote.Message)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Message::CopyFrom(const Message& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:cpb.remote.Message)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Message::IsInitialized() const {
  return true;
}

void Message::InternalSwap(Message* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Message, type_)
      + sizeof(Message::type_)
      - PROTOBUF_FIELD_OFFSET(Message, request_playlist_songs_)>(
          reinterpret_cast<char*>(&request_playlist_songs_),
          reinterpret_cast<char*>(&other->request_playlist_songs_));
  swap(version_, other->version_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Message::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_remotecontrolmessages_2eproto_getter, &descriptor_table_remotecontrolmessages_2eproto_once,
      file_level_metadata_remotecontrolmessages_2eproto[41]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace remote
}  // namespace cpb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::cpb::remote::SongMetadata* Arena::CreateMaybeMessage< ::cpb::remote::SongMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::SongMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Playlist* Arena::CreateMaybeMessage< ::cpb::remote::Playlist >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Playlist >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestPlaylists* Arena::CreateMaybeMessage< ::cpb::remote::RequestPlaylists >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestPlaylists >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestPlaylistSongs* Arena::CreateMaybeMessage< ::cpb::remote::RequestPlaylistSongs >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestPlaylistSongs >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestChangeSong* Arena::CreateMaybeMessage< ::cpb::remote::RequestChangeSong >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestChangeSong >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestSetVolume* Arena::CreateMaybeMessage< ::cpb::remote::RequestSetVolume >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestSetVolume >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Repeat* Arena::CreateMaybeMessage< ::cpb::remote::Repeat >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Repeat >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Shuffle* Arena::CreateMaybeMessage< ::cpb::remote::Shuffle >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Shuffle >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseClementineInfo* Arena::CreateMaybeMessage< ::cpb::remote::ResponseClementineInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseClementineInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseCurrentMetadata* Arena::CreateMaybeMessage< ::cpb::remote::ResponseCurrentMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseCurrentMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponsePlaylists* Arena::CreateMaybeMessage< ::cpb::remote::ResponsePlaylists >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponsePlaylists >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponsePlaylistSongs* Arena::CreateMaybeMessage< ::cpb::remote::ResponsePlaylistSongs >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponsePlaylistSongs >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseEngineStateChanged* Arena::CreateMaybeMessage< ::cpb::remote::ResponseEngineStateChanged >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseEngineStateChanged >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseUpdateTrackPosition* Arena::CreateMaybeMessage< ::cpb::remote::ResponseUpdateTrackPosition >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseUpdateTrackPosition >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestConnect* Arena::CreateMaybeMessage< ::cpb::remote::RequestConnect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestConnect >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseDisconnect* Arena::CreateMaybeMessage< ::cpb::remote::ResponseDisconnect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseDisconnect >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseActiveChanged* Arena::CreateMaybeMessage< ::cpb::remote::ResponseActiveChanged >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseActiveChanged >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestSetTrackPosition* Arena::CreateMaybeMessage< ::cpb::remote::RequestSetTrackPosition >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestSetTrackPosition >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestInsertUrls* Arena::CreateMaybeMessage< ::cpb::remote::RequestInsertUrls >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestInsertUrls >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestRemoveSongs* Arena::CreateMaybeMessage< ::cpb::remote::RequestRemoveSongs >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestRemoveSongs >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestOpenPlaylist* Arena::CreateMaybeMessage< ::cpb::remote::RequestOpenPlaylist >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestOpenPlaylist >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestClosePlaylist* Arena::CreateMaybeMessage< ::cpb::remote::RequestClosePlaylist >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestClosePlaylist >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestUpdatePlaylist* Arena::CreateMaybeMessage< ::cpb::remote::RequestUpdatePlaylist >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestUpdatePlaylist >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseLyrics* Arena::CreateMaybeMessage< ::cpb::remote::ResponseLyrics >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseLyrics >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Lyric* Arena::CreateMaybeMessage< ::cpb::remote::Lyric >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Lyric >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestDownloadSongs* Arena::CreateMaybeMessage< ::cpb::remote::RequestDownloadSongs >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestDownloadSongs >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseSongFileChunk* Arena::CreateMaybeMessage< ::cpb::remote::ResponseSongFileChunk >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseSongFileChunk >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseLibraryChunk* Arena::CreateMaybeMessage< ::cpb::remote::ResponseLibraryChunk >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseLibraryChunk >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseSongOffer* Arena::CreateMaybeMessage< ::cpb::remote::ResponseSongOffer >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseSongOffer >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestRateSong* Arena::CreateMaybeMessage< ::cpb::remote::RequestRateSong >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestRateSong >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseDownloadTotalSize* Arena::CreateMaybeMessage< ::cpb::remote::ResponseDownloadTotalSize >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseDownloadTotalSize >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestGlobalSearch* Arena::CreateMaybeMessage< ::cpb::remote::RequestGlobalSearch >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestGlobalSearch >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseGlobalSearch* Arena::CreateMaybeMessage< ::cpb::remote::ResponseGlobalSearch >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseGlobalSearch >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseTranscoderStatus* Arena::CreateMaybeMessage< ::cpb::remote::ResponseTranscoderStatus >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseTranscoderStatus >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseGlobalSearchStatus* Arena::CreateMaybeMessage< ::cpb::remote::ResponseGlobalSearchStatus >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseGlobalSearchStatus >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestListFiles* Arena::CreateMaybeMessage< ::cpb::remote::RequestListFiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestListFiles >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::FileMetadata* Arena::CreateMaybeMessage< ::cpb::remote::FileMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::FileMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseListFiles* Arena::CreateMaybeMessage< ::cpb::remote::ResponseListFiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseListFiles >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::RequestAppendFiles* Arena::CreateMaybeMessage< ::cpb::remote::RequestAppendFiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::RequestAppendFiles >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Stream* Arena::CreateMaybeMessage< ::cpb::remote::Stream >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Stream >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::ResponseSavedRadios* Arena::CreateMaybeMessage< ::cpb::remote::ResponseSavedRadios >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::ResponseSavedRadios >(arena);
}
template<> PROTOBUF_NOINLINE ::cpb::remote::Message* Arena::CreateMaybeMessage< ::cpb::remote::Message >(Arena* arena) {
  return Arena::CreateMessageInternal< ::cpb::remote::Message >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
