From c6327af2f386724dd45e73243844617e4da524e2 Mon Sep 17 00:00:00 2001 From: Paul Lietar Date: Mon, 21 Nov 2016 02:48:17 +0000 Subject: [PATCH] Include pre-generated protocol files. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A build script is used to ensure the source files haven’t been modified. --- Cargo.lock | 13 - README.md | 8 +- protocol/Cargo.toml | 5 +- protocol/build.rs | 135 +- protocol/build.sh | 29 + protocol/files.rs | 10 + protocol/proto/ad-hermes-proxy.proto | 2 + protocol/proto/appstore.proto | 2 + protocol/proto/authentication.proto | 1 + protocol/proto/facebook-publish.proto | 2 + protocol/proto/facebook.proto | 2 + protocol/proto/keyexchange.proto | 1 + protocol/proto/mercury.proto | 2 + protocol/proto/mergedprofile.proto | 2 + protocol/proto/metadata.proto | 2 + protocol/proto/playlist4changes.proto | 2 + protocol/proto/playlist4content.proto | 2 + protocol/proto/playlist4issues.proto | 2 + protocol/proto/playlist4meta.proto | 2 + protocol/proto/playlist4ops.proto | 2 + protocol/proto/popcount.proto | 2 + protocol/proto/presence.proto | 2 + protocol/proto/pubsub.proto | 2 + protocol/proto/radio.proto | 2 + protocol/proto/search.proto | 2 + protocol/proto/social.proto | 2 + protocol/proto/socialgraph.proto | 2 + protocol/proto/spirc.proto | 2 + protocol/proto/suggest.proto | 2 + protocol/proto/toplist.proto | 2 + protocol/src/authentication.rs | 5737 +++++++++++++++++++ protocol/src/keyexchange.rs | 7625 +++++++++++++++++++++++++ protocol/src/lib.rs | 15 +- protocol/src/mercury.rs | 2019 +++++++ protocol/src/metadata.rs | 6817 ++++++++++++++++++++++ protocol/src/pubsub.rs | 329 ++ protocol/src/spirc.rs | 4262 ++++++++++++++ 37 files changed, 26986 insertions(+), 64 deletions(-) create mode 100644 protocol/build.sh create mode 100644 protocol/files.rs create mode 100644 protocol/src/authentication.rs create mode 100644 protocol/src/keyexchange.rs create mode 100644 protocol/src/mercury.rs create mode 100644 protocol/src/metadata.rs create mode 100644 protocol/src/pubsub.rs create mode 100644 protocol/src/spirc.rs diff --git a/Cargo.lock b/Cargo.lock index 3e955fa9..5586d973 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -322,7 +322,6 @@ name = "librespot-protocol" version = "0.1.0" dependencies = [ "protobuf 1.0.24 (registry+https://github.com/rust-lang/crates.io-index)", - "protobuf_build 0.1.1 (git+https://github.com/plietar/rust-protobuf-build.git)", ] [[package]] @@ -615,17 +614,6 @@ name = "protobuf" version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -[[package]] -name = "protobuf_build" -version = "0.1.1" -source = "git+https://github.com/plietar/rust-protobuf-build.git#24d5a01ca035d0c00a3fae7ce5e26b6d2e68ddcb" -dependencies = [ - "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)", - "pkg-config 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", - "protobuf 1.0.24 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "protobuf_macros" version = "0.6.0" @@ -1324,7 +1312,6 @@ dependencies = [ "checksum portaudio 0.2.0 (git+https://github.com/mvdnes/portaudio-rs)" = "" "checksum portaudio_sys 0.1.1 (git+https://github.com/mvdnes/portaudio-rs)" = "" "checksum protobuf 1.0.24 (registry+https://github.com/rust-lang/crates.io-index)" = "6ec4c2fe04370298218a09ab53a534febf54c160c5554e4de987b6d73c916d5d" -"checksum protobuf_build 0.1.1 (git+https://github.com/plietar/rust-protobuf-build.git)" = "" "checksum protobuf_macros 0.6.0 (git+https://github.com/plietar/rust-protobuf-macros)" = "" "checksum quasi 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621ed00c72a1279d3272b5ad7137302e8f493ba19f726dcb5a3c7c9774972a64" "checksum quasi 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "314e56e9e59af71a5b1f09fab15e8e66ab2ccb786688f8d2e04d98b8d7cbc161" diff --git a/README.md b/README.md index 44ebadae..84baebbd 100644 --- a/README.md +++ b/README.md @@ -11,21 +11,21 @@ are however welcome to experiment with it. ## Building Rust 1.7.0 or later is required to build librespot. -It also requires a C and C++ toolchain, with libprotoc and portaudio. +It also requires a C, with portaudio. On debian / ubuntu, the following command will install these dependencies : ```shell -sudo apt-get install build-essential portaudio19-dev libprotoc-dev +sudo apt-get install build-essential portaudio19-dev ``` On Fedora systems, the following command will install these dependencies : ```shell -sudo dnf install portaudio-devel protobuf-devel make gcc gcc-c++ +sudo dnf install portaudio-devel make gcc ``` On OS X, using homebrew : ```shell -brew install portaudio protobuf +brew install portaudio ``` Once you've cloned this repository you can build *librespot* using `cargo`. diff --git a/protocol/Cargo.toml b/protocol/Cargo.toml index 60584321..3a8f5857 100644 --- a/protocol/Cargo.toml +++ b/protocol/Cargo.toml @@ -5,7 +5,4 @@ authors = ["Paul Liétar "] build = "build.rs" [dependencies] -protobuf = "~1.0.10" - -[build-dependencies.protobuf_build] -git = "https://github.com/plietar/rust-protobuf-build.git" +protobuf = "1.0.10" diff --git a/protocol/build.rs b/protocol/build.rs index 1cbfaa1f..f8ad050f 100644 --- a/protocol/build.rs +++ b/protocol/build.rs @@ -1,42 +1,105 @@ -extern crate protobuf_build; - -use std::env; -use std::path::PathBuf; +use std::io::prelude::*; use std::fs::File; -use std::io::{Read, Write}; + +mod files; fn main() { - let root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()); - let out = PathBuf::from(env::var("OUT_DIR").unwrap()); - let proto = root.join("proto"); - - let mut compiler = protobuf_build::Compiler::new(&proto, &out); - - let files = ["keyexchange", - "authentication", - "mercury", - "metadata", - "pubsub", - "spirc"]; - - for file in &files { - compiler.compile(&((*file).to_owned() + ".proto")).unwrap(); - - // Hack for rust-lang/rust#18810 - // Wrap the generated rust files with "pub mod { ... }", so they - // can be included. - let path = out.join(&((*file).to_owned() + ".rs")); - let contents = { - let mut src = File::open(path).unwrap(); - let mut contents = Vec::new(); - src.read_to_end(&mut contents).unwrap(); - contents - }; - - let mut dst = File::create(out.join(&((*file).to_owned() + ".rs"))).unwrap(); - dst.write_all(format!("pub mod {} {{\n", file).as_bytes()).unwrap(); - dst.write_all(&contents).unwrap(); - dst.write_all("}".as_bytes()).unwrap(); + for &(path, expected_checksum) in files::FILES { + let actual = cksum_file(path).unwrap(); + if expected_checksum != actual { + panic!("Checksum for {:?} does not match. Try running build.sh", path); + } } } +fn cksum_file>(path: T) -> std::io::Result { + let mut file = File::open(path)?; + let mut contents = Vec::new(); + file.read_to_end(&mut contents)?; + + Ok(cksum(&contents)) +} + +fn cksum>(data: T) -> u32 { + let data = data.as_ref(); + + let mut value = 0u32; + for x in data { + value = (value << 8) ^ CRC_LOOKUP_ARRAY[(*x as u32 ^ (value >> 24)) as usize]; + } + + let mut n = data.len(); + while n != 0 { + value = (value << 8) ^ CRC_LOOKUP_ARRAY[((n & 0xFF) as u32 ^ (value >> 24)) as usize]; + n >>= 8; + } + + !value +} + +static CRC_LOOKUP_ARRAY : &'static[u32] = &[ + 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, + 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, + 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, + 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, + 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, + 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, + 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, + 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, + 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, + 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, + 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, + 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, + 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, + 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, + 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, + 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, + 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, + 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, + 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, + 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, + 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, + 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, + 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, + 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, + 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, + 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, + 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, + 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, + 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, + 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, + 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, + 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, + 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, + 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, + 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, + 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, + 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, + 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, + 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, + 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, + 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, + 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, + 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, + 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, + 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, + 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, + 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, + 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, + 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, + 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, + 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, + 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, + 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, + 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, + 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, + 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, + 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, + 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, + 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, + 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, + 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, + 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, + 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, + 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 +]; diff --git a/protocol/build.sh b/protocol/build.sh new file mode 100644 index 00000000..53718858 --- /dev/null +++ b/protocol/build.sh @@ -0,0 +1,29 @@ +set -eu + +SRC="authentication keyexchange mercury + metadata pubsub spirc" + +cat > src/lib.rs < files.rs <> src/lib.rs + echo " (\"$src\", $checksum)," >> files.rs +done + +echo "];" >> files.rs diff --git a/protocol/files.rs b/protocol/files.rs new file mode 100644 index 00000000..cf81ed28 --- /dev/null +++ b/protocol/files.rs @@ -0,0 +1,10 @@ +// Autogenerated by build.sh + +pub const FILES : &'static [(&'static str, u32)] = &[ + ("proto/authentication.proto", 2098196376), + ("proto/keyexchange.proto", 451735664), + ("proto/mercury.proto", 709993906), + ("proto/metadata.proto", 488967056), + ("proto/pubsub.proto", 2686584829), + ("proto/spirc.proto", 400998103), +]; diff --git a/protocol/proto/ad-hermes-proxy.proto b/protocol/proto/ad-hermes-proxy.proto index 9fc50248..219bbcbf 100644 --- a/protocol/proto/ad-hermes-proxy.proto +++ b/protocol/proto/ad-hermes-proxy.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Rule { optional string type = 0x1; optional uint32 times = 0x2; diff --git a/protocol/proto/appstore.proto b/protocol/proto/appstore.proto index d526cf02..bddaaf30 100644 --- a/protocol/proto/appstore.proto +++ b/protocol/proto/appstore.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message AppInfo { optional string identifier = 0x1; optional int32 version_int = 0x2; diff --git a/protocol/proto/authentication.proto b/protocol/proto/authentication.proto index 8a15211c..3c0aff3e 100644 --- a/protocol/proto/authentication.proto +++ b/protocol/proto/authentication.proto @@ -1,3 +1,4 @@ +syntax = "proto2"; message ClientResponseEncrypted { required LoginCredentials login_credentials = 0xa; diff --git a/protocol/proto/facebook-publish.proto b/protocol/proto/facebook-publish.proto index 31af8c50..4edef249 100644 --- a/protocol/proto/facebook-publish.proto +++ b/protocol/proto/facebook-publish.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message EventReply { optional int32 queued = 0x1; optional RetryInfo retry = 0x2; diff --git a/protocol/proto/facebook.proto b/protocol/proto/facebook.proto index a0439a3a..8227c5a1 100644 --- a/protocol/proto/facebook.proto +++ b/protocol/proto/facebook.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Credential { optional string facebook_uid = 0x1; optional string access_token = 0x2; diff --git a/protocol/proto/keyexchange.proto b/protocol/proto/keyexchange.proto index 8a5813b3..0907c912 100644 --- a/protocol/proto/keyexchange.proto +++ b/protocol/proto/keyexchange.proto @@ -1,3 +1,4 @@ +syntax = "proto2"; message ClientHello { required BuildInfo build_info = 0xa; diff --git a/protocol/proto/mercury.proto b/protocol/proto/mercury.proto index c080bd10..2abdbcc4 100644 --- a/protocol/proto/mercury.proto +++ b/protocol/proto/mercury.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message MercuryMultiGetRequest { repeated MercuryRequest request = 0x1; } diff --git a/protocol/proto/mergedprofile.proto b/protocol/proto/mergedprofile.proto index 20f7dd5f..e283e1de 100644 --- a/protocol/proto/mergedprofile.proto +++ b/protocol/proto/mergedprofile.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message MergedProfileRequest { } diff --git a/protocol/proto/metadata.proto b/protocol/proto/metadata.proto index 8ca3371c..c5f706dc 100644 --- a/protocol/proto/metadata.proto +++ b/protocol/proto/metadata.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message TopTracks { optional string country = 0x1; repeated Track track = 0x2; diff --git a/protocol/proto/playlist4changes.proto b/protocol/proto/playlist4changes.proto index 145ee59c..73a1bd48 100644 --- a/protocol/proto/playlist4changes.proto +++ b/protocol/proto/playlist4changes.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + import "playlist4ops.proto"; import "playlist4meta.proto"; import "playlist4content.proto"; diff --git a/protocol/proto/playlist4content.proto b/protocol/proto/playlist4content.proto index c6db8edf..50d197fa 100644 --- a/protocol/proto/playlist4content.proto +++ b/protocol/proto/playlist4content.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + import "playlist4meta.proto"; import "playlist4issues.proto"; diff --git a/protocol/proto/playlist4issues.proto b/protocol/proto/playlist4issues.proto index 6f5c26bb..3808d532 100644 --- a/protocol/proto/playlist4issues.proto +++ b/protocol/proto/playlist4issues.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message ClientIssue { optional Level level = 0x1; enum Level { diff --git a/protocol/proto/playlist4meta.proto b/protocol/proto/playlist4meta.proto index 1acaef7c..4c22a9f0 100644 --- a/protocol/proto/playlist4meta.proto +++ b/protocol/proto/playlist4meta.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message ListChecksum { optional int32 version = 0x1; optional bytes sha1 = 0x4; diff --git a/protocol/proto/playlist4ops.proto b/protocol/proto/playlist4ops.proto index d1595712..dbbfcaa9 100644 --- a/protocol/proto/playlist4ops.proto +++ b/protocol/proto/playlist4ops.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + import "playlist4meta.proto"; import "playlist4content.proto"; diff --git a/protocol/proto/popcount.proto b/protocol/proto/popcount.proto index 3b2d1a36..7a0bac84 100644 --- a/protocol/proto/popcount.proto +++ b/protocol/proto/popcount.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message PopcountRequest { } diff --git a/protocol/proto/presence.proto b/protocol/proto/presence.proto index f74ba5f5..5e9be377 100644 --- a/protocol/proto/presence.proto +++ b/protocol/proto/presence.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message PlaylistPublishedState { optional string uri = 0x1; optional int64 timestamp = 0x2; diff --git a/protocol/proto/pubsub.proto b/protocol/proto/pubsub.proto index 94c2cd91..a781c377 100644 --- a/protocol/proto/pubsub.proto +++ b/protocol/proto/pubsub.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Subscription { optional string uri = 0x1; optional int32 expiry = 0x2; diff --git a/protocol/proto/radio.proto b/protocol/proto/radio.proto index b21aad2c..7a8f3bde 100644 --- a/protocol/proto/radio.proto +++ b/protocol/proto/radio.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message RadioRequest { repeated string uris = 0x1; optional int32 salt = 0x2; diff --git a/protocol/proto/search.proto b/protocol/proto/search.proto index 776cb0ad..38b717f7 100644 --- a/protocol/proto/search.proto +++ b/protocol/proto/search.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message SearchRequest { optional string query = 0x1; optional Type type = 0x2; diff --git a/protocol/proto/social.proto b/protocol/proto/social.proto index 542cfb69..58d39a18 100644 --- a/protocol/proto/social.proto +++ b/protocol/proto/social.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message DecorationData { optional string username = 0x1; optional string full_name = 0x2; diff --git a/protocol/proto/socialgraph.proto b/protocol/proto/socialgraph.proto index 2be79106..3adc1306 100644 --- a/protocol/proto/socialgraph.proto +++ b/protocol/proto/socialgraph.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message CountReply { repeated int32 counts = 0x1; } diff --git a/protocol/proto/spirc.proto b/protocol/proto/spirc.proto index 0c0f919f..5b4f4bb9 100644 --- a/protocol/proto/spirc.proto +++ b/protocol/proto/spirc.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Frame { optional uint32 version = 0x1; optional string ident = 0x2; diff --git a/protocol/proto/suggest.proto b/protocol/proto/suggest.proto index 1b88977e..ef45f1e2 100644 --- a/protocol/proto/suggest.proto +++ b/protocol/proto/suggest.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Track { optional bytes gid = 0x1; optional string name = 0x2; diff --git a/protocol/proto/toplist.proto b/protocol/proto/toplist.proto index c4073830..1a12159f 100644 --- a/protocol/proto/toplist.proto +++ b/protocol/proto/toplist.proto @@ -1,3 +1,5 @@ +syntax = "proto2"; + message Toplist { repeated string items = 0x1; } diff --git a/protocol/src/authentication.rs b/protocol/src/authentication.rs new file mode 100644 index 00000000..2c14b4d0 --- /dev/null +++ b/protocol/src/authentication.rs @@ -0,0 +1,5737 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct ClientResponseEncrypted { + // message fields + login_credentials: ::protobuf::SingularPtrField, + account_creation: ::std::option::Option, + fingerprint_response: ::protobuf::SingularPtrField, + peer_ticket: ::protobuf::SingularPtrField, + system_info: ::protobuf::SingularPtrField, + platform_model: ::protobuf::SingularField<::std::string::String>, + version_string: ::protobuf::SingularField<::std::string::String>, + appkey: ::protobuf::SingularPtrField, + client_info: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ClientResponseEncrypted {} + +impl ClientResponseEncrypted { + pub fn new() -> ClientResponseEncrypted { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ClientResponseEncrypted { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ClientResponseEncrypted, + }; + unsafe { + instance.get(|| { + ClientResponseEncrypted { + login_credentials: ::protobuf::SingularPtrField::none(), + account_creation: ::std::option::Option::None, + fingerprint_response: ::protobuf::SingularPtrField::none(), + peer_ticket: ::protobuf::SingularPtrField::none(), + system_info: ::protobuf::SingularPtrField::none(), + platform_model: ::protobuf::SingularField::none(), + version_string: ::protobuf::SingularField::none(), + appkey: ::protobuf::SingularPtrField::none(), + client_info: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .LoginCredentials login_credentials = 10; + + pub fn clear_login_credentials(&mut self) { + self.login_credentials.clear(); + } + + pub fn has_login_credentials(&self) -> bool { + self.login_credentials.is_some() + } + + // Param is passed by value, moved + pub fn set_login_credentials(&mut self, v: LoginCredentials) { + self.login_credentials = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_login_credentials(&mut self) -> &mut LoginCredentials { + if self.login_credentials.is_none() { + self.login_credentials.set_default(); + }; + self.login_credentials.as_mut().unwrap() + } + + // Take field + pub fn take_login_credentials(&mut self) -> LoginCredentials { + self.login_credentials.take().unwrap_or_else(|| LoginCredentials::new()) + } + + pub fn get_login_credentials(&self) -> &LoginCredentials { + self.login_credentials.as_ref().unwrap_or_else(|| LoginCredentials::default_instance()) + } + + // optional .AccountCreation account_creation = 20; + + pub fn clear_account_creation(&mut self) { + self.account_creation = ::std::option::Option::None; + } + + pub fn has_account_creation(&self) -> bool { + self.account_creation.is_some() + } + + // Param is passed by value, moved + pub fn set_account_creation(&mut self, v: AccountCreation) { + self.account_creation = ::std::option::Option::Some(v); + } + + pub fn get_account_creation(&self) -> AccountCreation { + self.account_creation.unwrap_or(AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT) + } + + // optional .FingerprintResponseUnion fingerprint_response = 30; + + pub fn clear_fingerprint_response(&mut self) { + self.fingerprint_response.clear(); + } + + pub fn has_fingerprint_response(&self) -> bool { + self.fingerprint_response.is_some() + } + + // Param is passed by value, moved + pub fn set_fingerprint_response(&mut self, v: FingerprintResponseUnion) { + self.fingerprint_response = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_fingerprint_response(&mut self) -> &mut FingerprintResponseUnion { + if self.fingerprint_response.is_none() { + self.fingerprint_response.set_default(); + }; + self.fingerprint_response.as_mut().unwrap() + } + + // Take field + pub fn take_fingerprint_response(&mut self) -> FingerprintResponseUnion { + self.fingerprint_response.take().unwrap_or_else(|| FingerprintResponseUnion::new()) + } + + pub fn get_fingerprint_response(&self) -> &FingerprintResponseUnion { + self.fingerprint_response.as_ref().unwrap_or_else(|| FingerprintResponseUnion::default_instance()) + } + + // optional .PeerTicketUnion peer_ticket = 40; + + pub fn clear_peer_ticket(&mut self) { + self.peer_ticket.clear(); + } + + pub fn has_peer_ticket(&self) -> bool { + self.peer_ticket.is_some() + } + + // Param is passed by value, moved + pub fn set_peer_ticket(&mut self, v: PeerTicketUnion) { + self.peer_ticket = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_peer_ticket(&mut self) -> &mut PeerTicketUnion { + if self.peer_ticket.is_none() { + self.peer_ticket.set_default(); + }; + self.peer_ticket.as_mut().unwrap() + } + + // Take field + pub fn take_peer_ticket(&mut self) -> PeerTicketUnion { + self.peer_ticket.take().unwrap_or_else(|| PeerTicketUnion::new()) + } + + pub fn get_peer_ticket(&self) -> &PeerTicketUnion { + self.peer_ticket.as_ref().unwrap_or_else(|| PeerTicketUnion::default_instance()) + } + + // required .SystemInfo system_info = 50; + + pub fn clear_system_info(&mut self) { + self.system_info.clear(); + } + + pub fn has_system_info(&self) -> bool { + self.system_info.is_some() + } + + // Param is passed by value, moved + pub fn set_system_info(&mut self, v: SystemInfo) { + self.system_info = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_system_info(&mut self) -> &mut SystemInfo { + if self.system_info.is_none() { + self.system_info.set_default(); + }; + self.system_info.as_mut().unwrap() + } + + // Take field + pub fn take_system_info(&mut self) -> SystemInfo { + self.system_info.take().unwrap_or_else(|| SystemInfo::new()) + } + + pub fn get_system_info(&self) -> &SystemInfo { + self.system_info.as_ref().unwrap_or_else(|| SystemInfo::default_instance()) + } + + // optional string platform_model = 60; + + pub fn clear_platform_model(&mut self) { + self.platform_model.clear(); + } + + pub fn has_platform_model(&self) -> bool { + self.platform_model.is_some() + } + + // Param is passed by value, moved + pub fn set_platform_model(&mut self, v: ::std::string::String) { + self.platform_model = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_platform_model(&mut self) -> &mut ::std::string::String { + if self.platform_model.is_none() { + self.platform_model.set_default(); + }; + self.platform_model.as_mut().unwrap() + } + + // Take field + pub fn take_platform_model(&mut self) -> ::std::string::String { + self.platform_model.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_platform_model(&self) -> &str { + match self.platform_model.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string version_string = 70; + + pub fn clear_version_string(&mut self) { + self.version_string.clear(); + } + + pub fn has_version_string(&self) -> bool { + self.version_string.is_some() + } + + // Param is passed by value, moved + pub fn set_version_string(&mut self, v: ::std::string::String) { + self.version_string = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_version_string(&mut self) -> &mut ::std::string::String { + if self.version_string.is_none() { + self.version_string.set_default(); + }; + self.version_string.as_mut().unwrap() + } + + // Take field + pub fn take_version_string(&mut self) -> ::std::string::String { + self.version_string.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_version_string(&self) -> &str { + match self.version_string.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional .LibspotifyAppKey appkey = 80; + + pub fn clear_appkey(&mut self) { + self.appkey.clear(); + } + + pub fn has_appkey(&self) -> bool { + self.appkey.is_some() + } + + // Param is passed by value, moved + pub fn set_appkey(&mut self, v: LibspotifyAppKey) { + self.appkey = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_appkey(&mut self) -> &mut LibspotifyAppKey { + if self.appkey.is_none() { + self.appkey.set_default(); + }; + self.appkey.as_mut().unwrap() + } + + // Take field + pub fn take_appkey(&mut self) -> LibspotifyAppKey { + self.appkey.take().unwrap_or_else(|| LibspotifyAppKey::new()) + } + + pub fn get_appkey(&self) -> &LibspotifyAppKey { + self.appkey.as_ref().unwrap_or_else(|| LibspotifyAppKey::default_instance()) + } + + // optional .ClientInfo client_info = 90; + + pub fn clear_client_info(&mut self) { + self.client_info.clear(); + } + + pub fn has_client_info(&self) -> bool { + self.client_info.is_some() + } + + // Param is passed by value, moved + pub fn set_client_info(&mut self, v: ClientInfo) { + self.client_info = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_client_info(&mut self) -> &mut ClientInfo { + if self.client_info.is_none() { + self.client_info.set_default(); + }; + self.client_info.as_mut().unwrap() + } + + // Take field + pub fn take_client_info(&mut self) -> ClientInfo { + self.client_info.take().unwrap_or_else(|| ClientInfo::new()) + } + + pub fn get_client_info(&self) -> &ClientInfo { + self.client_info.as_ref().unwrap_or_else(|| ClientInfo::default_instance()) + } +} + +impl ::protobuf::Message for ClientResponseEncrypted { + fn is_initialized(&self) -> bool { + if self.login_credentials.is_none() { + return false; + }; + if self.system_info.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_credentials)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.account_creation = ::std::option::Option::Some(tmp); + }, + 30 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fingerprint_response)); + }, + 40 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.peer_ticket)); + }, + 50 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.system_info)); + }, + 60 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.platform_model)); + }, + 70 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.version_string)); + }, + 80 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.appkey)); + }, + 90 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.client_info)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.login_credentials { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.account_creation { + my_size += ::protobuf::rt::enum_size(20, *value); + }; + for value in &self.fingerprint_response { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.peer_ticket { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.system_info { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.platform_model { + my_size += ::protobuf::rt::string_size(60, &value); + }; + for value in &self.version_string { + my_size += ::protobuf::rt::string_size(70, &value); + }; + for value in &self.appkey { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.client_info { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.login_credentials.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.account_creation { + try!(os.write_enum(20, v.value())); + }; + if let Some(v) = self.fingerprint_response.as_ref() { + try!(os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.peer_ticket.as_ref() { + try!(os.write_tag(40, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.system_info.as_ref() { + try!(os.write_tag(50, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.platform_model.as_ref() { + try!(os.write_string(60, &v)); + }; + if let Some(v) = self.version_string.as_ref() { + try!(os.write_string(70, &v)); + }; + if let Some(v) = self.appkey.as_ref() { + try!(os.write_tag(80, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.client_info.as_ref() { + try!(os.write_tag(90, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ClientResponseEncrypted { + fn new() -> ClientResponseEncrypted { + ClientResponseEncrypted::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "login_credentials", + ClientResponseEncrypted::has_login_credentials, + ClientResponseEncrypted::get_login_credentials, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "account_creation", + ClientResponseEncrypted::has_account_creation, + ClientResponseEncrypted::get_account_creation, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "fingerprint_response", + ClientResponseEncrypted::has_fingerprint_response, + ClientResponseEncrypted::get_fingerprint_response, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "peer_ticket", + ClientResponseEncrypted::has_peer_ticket, + ClientResponseEncrypted::get_peer_ticket, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "system_info", + ClientResponseEncrypted::has_system_info, + ClientResponseEncrypted::get_system_info, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "platform_model", + ClientResponseEncrypted::has_platform_model, + ClientResponseEncrypted::get_platform_model, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "version_string", + ClientResponseEncrypted::has_version_string, + ClientResponseEncrypted::get_version_string, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "appkey", + ClientResponseEncrypted::has_appkey, + ClientResponseEncrypted::get_appkey, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "client_info", + ClientResponseEncrypted::has_client_info, + ClientResponseEncrypted::get_client_info, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ClientResponseEncrypted", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ClientResponseEncrypted { + fn clear(&mut self) { + self.clear_login_credentials(); + self.clear_account_creation(); + self.clear_fingerprint_response(); + self.clear_peer_ticket(); + self.clear_system_info(); + self.clear_platform_model(); + self.clear_version_string(); + self.clear_appkey(); + self.clear_client_info(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ClientResponseEncrypted { + fn eq(&self, other: &ClientResponseEncrypted) -> bool { + self.login_credentials == other.login_credentials && + self.account_creation == other.account_creation && + self.fingerprint_response == other.fingerprint_response && + self.peer_ticket == other.peer_ticket && + self.system_info == other.system_info && + self.platform_model == other.platform_model && + self.version_string == other.version_string && + self.appkey == other.appkey && + self.client_info == other.client_info && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ClientResponseEncrypted { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCredentials { + // message fields + username: ::protobuf::SingularField<::std::string::String>, + typ: ::std::option::Option, + auth_data: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCredentials {} + +impl LoginCredentials { + pub fn new() -> LoginCredentials { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCredentials { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCredentials, + }; + unsafe { + instance.get(|| { + LoginCredentials { + username: ::protobuf::SingularField::none(), + typ: ::std::option::Option::None, + auth_data: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string username = 10; + + pub fn clear_username(&mut self) { + self.username.clear(); + } + + pub fn has_username(&self) -> bool { + self.username.is_some() + } + + // Param is passed by value, moved + pub fn set_username(&mut self, v: ::std::string::String) { + self.username = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_username(&mut self) -> &mut ::std::string::String { + if self.username.is_none() { + self.username.set_default(); + }; + self.username.as_mut().unwrap() + } + + // Take field + pub fn take_username(&mut self) -> ::std::string::String { + self.username.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_username(&self) -> &str { + match self.username.as_ref() { + Some(v) => &v, + None => "", + } + } + + // required .AuthenticationType typ = 20; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: AuthenticationType) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> AuthenticationType { + self.typ.unwrap_or(AuthenticationType::AUTHENTICATION_USER_PASS) + } + + // optional bytes auth_data = 30; + + pub fn clear_auth_data(&mut self) { + self.auth_data.clear(); + } + + pub fn has_auth_data(&self) -> bool { + self.auth_data.is_some() + } + + // Param is passed by value, moved + pub fn set_auth_data(&mut self, v: ::std::vec::Vec) { + self.auth_data = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_auth_data(&mut self) -> &mut ::std::vec::Vec { + if self.auth_data.is_none() { + self.auth_data.set_default(); + }; + self.auth_data.as_mut().unwrap() + } + + // Take field + pub fn take_auth_data(&mut self) -> ::std::vec::Vec { + self.auth_data.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_auth_data(&self) -> &[u8] { + match self.auth_data.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for LoginCredentials { + fn is_initialized(&self) -> bool { + if self.typ.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.username)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 30 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.auth_data)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.username { + my_size += ::protobuf::rt::string_size(10, &value); + }; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(20, *value); + }; + for value in &self.auth_data { + my_size += ::protobuf::rt::bytes_size(30, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.username.as_ref() { + try!(os.write_string(10, &v)); + }; + if let Some(v) = self.typ { + try!(os.write_enum(20, v.value())); + }; + if let Some(v) = self.auth_data.as_ref() { + try!(os.write_bytes(30, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCredentials { + fn new() -> LoginCredentials { + LoginCredentials::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "username", + LoginCredentials::has_username, + LoginCredentials::get_username, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + LoginCredentials::has_typ, + LoginCredentials::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "auth_data", + LoginCredentials::has_auth_data, + LoginCredentials::get_auth_data, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCredentials", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCredentials { + fn clear(&mut self) { + self.clear_username(); + self.clear_typ(); + self.clear_auth_data(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCredentials { + fn eq(&self, other: &LoginCredentials) -> bool { + self.username == other.username && + self.typ == other.typ && + self.auth_data == other.auth_data && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCredentials { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintResponseUnion { + // message fields + grain: ::protobuf::SingularPtrField, + hmac_ripemd: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintResponseUnion {} + +impl FingerprintResponseUnion { + pub fn new() -> FingerprintResponseUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintResponseUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintResponseUnion, + }; + unsafe { + instance.get(|| { + FingerprintResponseUnion { + grain: ::protobuf::SingularPtrField::none(), + hmac_ripemd: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .FingerprintGrainResponse grain = 10; + + pub fn clear_grain(&mut self) { + self.grain.clear(); + } + + pub fn has_grain(&self) -> bool { + self.grain.is_some() + } + + // Param is passed by value, moved + pub fn set_grain(&mut self, v: FingerprintGrainResponse) { + self.grain = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_grain(&mut self) -> &mut FingerprintGrainResponse { + if self.grain.is_none() { + self.grain.set_default(); + }; + self.grain.as_mut().unwrap() + } + + // Take field + pub fn take_grain(&mut self) -> FingerprintGrainResponse { + self.grain.take().unwrap_or_else(|| FingerprintGrainResponse::new()) + } + + pub fn get_grain(&self) -> &FingerprintGrainResponse { + self.grain.as_ref().unwrap_or_else(|| FingerprintGrainResponse::default_instance()) + } + + // optional .FingerprintHmacRipemdResponse hmac_ripemd = 20; + + pub fn clear_hmac_ripemd(&mut self) { + self.hmac_ripemd.clear(); + } + + pub fn has_hmac_ripemd(&self) -> bool { + self.hmac_ripemd.is_some() + } + + // Param is passed by value, moved + pub fn set_hmac_ripemd(&mut self, v: FingerprintHmacRipemdResponse) { + self.hmac_ripemd = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hmac_ripemd(&mut self) -> &mut FingerprintHmacRipemdResponse { + if self.hmac_ripemd.is_none() { + self.hmac_ripemd.set_default(); + }; + self.hmac_ripemd.as_mut().unwrap() + } + + // Take field + pub fn take_hmac_ripemd(&mut self) -> FingerprintHmacRipemdResponse { + self.hmac_ripemd.take().unwrap_or_else(|| FingerprintHmacRipemdResponse::new()) + } + + pub fn get_hmac_ripemd(&self) -> &FingerprintHmacRipemdResponse { + self.hmac_ripemd.as_ref().unwrap_or_else(|| FingerprintHmacRipemdResponse::default_instance()) + } +} + +impl ::protobuf::Message for FingerprintResponseUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.grain)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.hmac_ripemd)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.grain { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.hmac_ripemd { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.grain.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.hmac_ripemd.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintResponseUnion { + fn new() -> FingerprintResponseUnion { + FingerprintResponseUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "grain", + FingerprintResponseUnion::has_grain, + FingerprintResponseUnion::get_grain, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "hmac_ripemd", + FingerprintResponseUnion::has_hmac_ripemd, + FingerprintResponseUnion::get_hmac_ripemd, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintResponseUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintResponseUnion { + fn clear(&mut self) { + self.clear_grain(); + self.clear_hmac_ripemd(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintResponseUnion { + fn eq(&self, other: &FingerprintResponseUnion) -> bool { + self.grain == other.grain && + self.hmac_ripemd == other.hmac_ripemd && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintResponseUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintGrainResponse { + // message fields + encrypted_key: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintGrainResponse {} + +impl FingerprintGrainResponse { + pub fn new() -> FingerprintGrainResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintGrainResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintGrainResponse, + }; + unsafe { + instance.get(|| { + FingerprintGrainResponse { + encrypted_key: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes encrypted_key = 10; + + pub fn clear_encrypted_key(&mut self) { + self.encrypted_key.clear(); + } + + pub fn has_encrypted_key(&self) -> bool { + self.encrypted_key.is_some() + } + + // Param is passed by value, moved + pub fn set_encrypted_key(&mut self, v: ::std::vec::Vec) { + self.encrypted_key = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_encrypted_key(&mut self) -> &mut ::std::vec::Vec { + if self.encrypted_key.is_none() { + self.encrypted_key.set_default(); + }; + self.encrypted_key.as_mut().unwrap() + } + + // Take field + pub fn take_encrypted_key(&mut self) -> ::std::vec::Vec { + self.encrypted_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_encrypted_key(&self) -> &[u8] { + match self.encrypted_key.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for FingerprintGrainResponse { + fn is_initialized(&self) -> bool { + if self.encrypted_key.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.encrypted_key)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.encrypted_key { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.encrypted_key.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintGrainResponse { + fn new() -> FingerprintGrainResponse { + FingerprintGrainResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "encrypted_key", + FingerprintGrainResponse::has_encrypted_key, + FingerprintGrainResponse::get_encrypted_key, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintGrainResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintGrainResponse { + fn clear(&mut self) { + self.clear_encrypted_key(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintGrainResponse { + fn eq(&self, other: &FingerprintGrainResponse) -> bool { + self.encrypted_key == other.encrypted_key && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintGrainResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintHmacRipemdResponse { + // message fields + hmac: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintHmacRipemdResponse {} + +impl FingerprintHmacRipemdResponse { + pub fn new() -> FingerprintHmacRipemdResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintHmacRipemdResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintHmacRipemdResponse, + }; + unsafe { + instance.get(|| { + FingerprintHmacRipemdResponse { + hmac: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes hmac = 10; + + pub fn clear_hmac(&mut self) { + self.hmac.clear(); + } + + pub fn has_hmac(&self) -> bool { + self.hmac.is_some() + } + + // Param is passed by value, moved + pub fn set_hmac(&mut self, v: ::std::vec::Vec) { + self.hmac = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hmac(&mut self) -> &mut ::std::vec::Vec { + if self.hmac.is_none() { + self.hmac.set_default(); + }; + self.hmac.as_mut().unwrap() + } + + // Take field + pub fn take_hmac(&mut self) -> ::std::vec::Vec { + self.hmac.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_hmac(&self) -> &[u8] { + match self.hmac.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for FingerprintHmacRipemdResponse { + fn is_initialized(&self) -> bool { + if self.hmac.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.hmac)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.hmac { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.hmac.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintHmacRipemdResponse { + fn new() -> FingerprintHmacRipemdResponse { + FingerprintHmacRipemdResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "hmac", + FingerprintHmacRipemdResponse::has_hmac, + FingerprintHmacRipemdResponse::get_hmac, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintHmacRipemdResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintHmacRipemdResponse { + fn clear(&mut self) { + self.clear_hmac(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintHmacRipemdResponse { + fn eq(&self, other: &FingerprintHmacRipemdResponse) -> bool { + self.hmac == other.hmac && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintHmacRipemdResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PeerTicketUnion { + // message fields + public_key: ::protobuf::SingularPtrField, + old_ticket: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PeerTicketUnion {} + +impl PeerTicketUnion { + pub fn new() -> PeerTicketUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PeerTicketUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PeerTicketUnion, + }; + unsafe { + instance.get(|| { + PeerTicketUnion { + public_key: ::protobuf::SingularPtrField::none(), + old_ticket: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .PeerTicketPublicKey public_key = 10; + + pub fn clear_public_key(&mut self) { + self.public_key.clear(); + } + + pub fn has_public_key(&self) -> bool { + self.public_key.is_some() + } + + // Param is passed by value, moved + pub fn set_public_key(&mut self, v: PeerTicketPublicKey) { + self.public_key = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_public_key(&mut self) -> &mut PeerTicketPublicKey { + if self.public_key.is_none() { + self.public_key.set_default(); + }; + self.public_key.as_mut().unwrap() + } + + // Take field + pub fn take_public_key(&mut self) -> PeerTicketPublicKey { + self.public_key.take().unwrap_or_else(|| PeerTicketPublicKey::new()) + } + + pub fn get_public_key(&self) -> &PeerTicketPublicKey { + self.public_key.as_ref().unwrap_or_else(|| PeerTicketPublicKey::default_instance()) + } + + // optional .PeerTicketOld old_ticket = 20; + + pub fn clear_old_ticket(&mut self) { + self.old_ticket.clear(); + } + + pub fn has_old_ticket(&self) -> bool { + self.old_ticket.is_some() + } + + // Param is passed by value, moved + pub fn set_old_ticket(&mut self, v: PeerTicketOld) { + self.old_ticket = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_old_ticket(&mut self) -> &mut PeerTicketOld { + if self.old_ticket.is_none() { + self.old_ticket.set_default(); + }; + self.old_ticket.as_mut().unwrap() + } + + // Take field + pub fn take_old_ticket(&mut self) -> PeerTicketOld { + self.old_ticket.take().unwrap_or_else(|| PeerTicketOld::new()) + } + + pub fn get_old_ticket(&self) -> &PeerTicketOld { + self.old_ticket.as_ref().unwrap_or_else(|| PeerTicketOld::default_instance()) + } +} + +impl ::protobuf::Message for PeerTicketUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.public_key)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.old_ticket)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.public_key { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.old_ticket { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.public_key.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.old_ticket.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PeerTicketUnion { + fn new() -> PeerTicketUnion { + PeerTicketUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "public_key", + PeerTicketUnion::has_public_key, + PeerTicketUnion::get_public_key, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "old_ticket", + PeerTicketUnion::has_old_ticket, + PeerTicketUnion::get_old_ticket, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PeerTicketUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PeerTicketUnion { + fn clear(&mut self) { + self.clear_public_key(); + self.clear_old_ticket(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PeerTicketUnion { + fn eq(&self, other: &PeerTicketUnion) -> bool { + self.public_key == other.public_key && + self.old_ticket == other.old_ticket && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PeerTicketUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PeerTicketPublicKey { + // message fields + public_key: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PeerTicketPublicKey {} + +impl PeerTicketPublicKey { + pub fn new() -> PeerTicketPublicKey { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PeerTicketPublicKey { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PeerTicketPublicKey, + }; + unsafe { + instance.get(|| { + PeerTicketPublicKey { + public_key: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes public_key = 10; + + pub fn clear_public_key(&mut self) { + self.public_key.clear(); + } + + pub fn has_public_key(&self) -> bool { + self.public_key.is_some() + } + + // Param is passed by value, moved + pub fn set_public_key(&mut self, v: ::std::vec::Vec) { + self.public_key = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { + if self.public_key.is_none() { + self.public_key.set_default(); + }; + self.public_key.as_mut().unwrap() + } + + // Take field + pub fn take_public_key(&mut self) -> ::std::vec::Vec { + self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_public_key(&self) -> &[u8] { + match self.public_key.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for PeerTicketPublicKey { + fn is_initialized(&self) -> bool { + if self.public_key.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.public_key)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.public_key { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.public_key.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PeerTicketPublicKey { + fn new() -> PeerTicketPublicKey { + PeerTicketPublicKey::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "public_key", + PeerTicketPublicKey::has_public_key, + PeerTicketPublicKey::get_public_key, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PeerTicketPublicKey", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PeerTicketPublicKey { + fn clear(&mut self) { + self.clear_public_key(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PeerTicketPublicKey { + fn eq(&self, other: &PeerTicketPublicKey) -> bool { + self.public_key == other.public_key && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PeerTicketPublicKey { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PeerTicketOld { + // message fields + peer_ticket: ::protobuf::SingularField<::std::vec::Vec>, + peer_ticket_signature: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PeerTicketOld {} + +impl PeerTicketOld { + pub fn new() -> PeerTicketOld { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PeerTicketOld { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PeerTicketOld, + }; + unsafe { + instance.get(|| { + PeerTicketOld { + peer_ticket: ::protobuf::SingularField::none(), + peer_ticket_signature: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes peer_ticket = 10; + + pub fn clear_peer_ticket(&mut self) { + self.peer_ticket.clear(); + } + + pub fn has_peer_ticket(&self) -> bool { + self.peer_ticket.is_some() + } + + // Param is passed by value, moved + pub fn set_peer_ticket(&mut self, v: ::std::vec::Vec) { + self.peer_ticket = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_peer_ticket(&mut self) -> &mut ::std::vec::Vec { + if self.peer_ticket.is_none() { + self.peer_ticket.set_default(); + }; + self.peer_ticket.as_mut().unwrap() + } + + // Take field + pub fn take_peer_ticket(&mut self) -> ::std::vec::Vec { + self.peer_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_peer_ticket(&self) -> &[u8] { + match self.peer_ticket.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required bytes peer_ticket_signature = 20; + + pub fn clear_peer_ticket_signature(&mut self) { + self.peer_ticket_signature.clear(); + } + + pub fn has_peer_ticket_signature(&self) -> bool { + self.peer_ticket_signature.is_some() + } + + // Param is passed by value, moved + pub fn set_peer_ticket_signature(&mut self, v: ::std::vec::Vec) { + self.peer_ticket_signature = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_peer_ticket_signature(&mut self) -> &mut ::std::vec::Vec { + if self.peer_ticket_signature.is_none() { + self.peer_ticket_signature.set_default(); + }; + self.peer_ticket_signature.as_mut().unwrap() + } + + // Take field + pub fn take_peer_ticket_signature(&mut self) -> ::std::vec::Vec { + self.peer_ticket_signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_peer_ticket_signature(&self) -> &[u8] { + match self.peer_ticket_signature.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for PeerTicketOld { + fn is_initialized(&self) -> bool { + if self.peer_ticket.is_none() { + return false; + }; + if self.peer_ticket_signature.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.peer_ticket)); + }, + 20 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.peer_ticket_signature)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.peer_ticket { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + for value in &self.peer_ticket_signature { + my_size += ::protobuf::rt::bytes_size(20, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.peer_ticket.as_ref() { + try!(os.write_bytes(10, &v)); + }; + if let Some(v) = self.peer_ticket_signature.as_ref() { + try!(os.write_bytes(20, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PeerTicketOld { + fn new() -> PeerTicketOld { + PeerTicketOld::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "peer_ticket", + PeerTicketOld::has_peer_ticket, + PeerTicketOld::get_peer_ticket, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "peer_ticket_signature", + PeerTicketOld::has_peer_ticket_signature, + PeerTicketOld::get_peer_ticket_signature, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PeerTicketOld", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PeerTicketOld { + fn clear(&mut self) { + self.clear_peer_ticket(); + self.clear_peer_ticket_signature(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PeerTicketOld { + fn eq(&self, other: &PeerTicketOld) -> bool { + self.peer_ticket == other.peer_ticket && + self.peer_ticket_signature == other.peer_ticket_signature && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PeerTicketOld { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct SystemInfo { + // message fields + cpu_family: ::std::option::Option, + cpu_subtype: ::std::option::Option, + cpu_ext: ::std::option::Option, + brand: ::std::option::Option, + brand_flags: ::std::option::Option, + os: ::std::option::Option, + os_version: ::std::option::Option, + os_ext: ::std::option::Option, + system_information_string: ::protobuf::SingularField<::std::string::String>, + device_id: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for SystemInfo {} + +impl SystemInfo { + pub fn new() -> SystemInfo { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static SystemInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SystemInfo, + }; + unsafe { + instance.get(|| { + SystemInfo { + cpu_family: ::std::option::Option::None, + cpu_subtype: ::std::option::Option::None, + cpu_ext: ::std::option::Option::None, + brand: ::std::option::Option::None, + brand_flags: ::std::option::Option::None, + os: ::std::option::Option::None, + os_version: ::std::option::Option::None, + os_ext: ::std::option::Option::None, + system_information_string: ::protobuf::SingularField::none(), + device_id: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .CpuFamily cpu_family = 10; + + pub fn clear_cpu_family(&mut self) { + self.cpu_family = ::std::option::Option::None; + } + + pub fn has_cpu_family(&self) -> bool { + self.cpu_family.is_some() + } + + // Param is passed by value, moved + pub fn set_cpu_family(&mut self, v: CpuFamily) { + self.cpu_family = ::std::option::Option::Some(v); + } + + pub fn get_cpu_family(&self) -> CpuFamily { + self.cpu_family.unwrap_or(CpuFamily::CPU_UNKNOWN) + } + + // optional uint32 cpu_subtype = 20; + + pub fn clear_cpu_subtype(&mut self) { + self.cpu_subtype = ::std::option::Option::None; + } + + pub fn has_cpu_subtype(&self) -> bool { + self.cpu_subtype.is_some() + } + + // Param is passed by value, moved + pub fn set_cpu_subtype(&mut self, v: u32) { + self.cpu_subtype = ::std::option::Option::Some(v); + } + + pub fn get_cpu_subtype(&self) -> u32 { + self.cpu_subtype.unwrap_or(0) + } + + // optional uint32 cpu_ext = 30; + + pub fn clear_cpu_ext(&mut self) { + self.cpu_ext = ::std::option::Option::None; + } + + pub fn has_cpu_ext(&self) -> bool { + self.cpu_ext.is_some() + } + + // Param is passed by value, moved + pub fn set_cpu_ext(&mut self, v: u32) { + self.cpu_ext = ::std::option::Option::Some(v); + } + + pub fn get_cpu_ext(&self) -> u32 { + self.cpu_ext.unwrap_or(0) + } + + // optional .Brand brand = 40; + + pub fn clear_brand(&mut self) { + self.brand = ::std::option::Option::None; + } + + pub fn has_brand(&self) -> bool { + self.brand.is_some() + } + + // Param is passed by value, moved + pub fn set_brand(&mut self, v: Brand) { + self.brand = ::std::option::Option::Some(v); + } + + pub fn get_brand(&self) -> Brand { + self.brand.unwrap_or(Brand::BRAND_UNBRANDED) + } + + // optional uint32 brand_flags = 50; + + pub fn clear_brand_flags(&mut self) { + self.brand_flags = ::std::option::Option::None; + } + + pub fn has_brand_flags(&self) -> bool { + self.brand_flags.is_some() + } + + // Param is passed by value, moved + pub fn set_brand_flags(&mut self, v: u32) { + self.brand_flags = ::std::option::Option::Some(v); + } + + pub fn get_brand_flags(&self) -> u32 { + self.brand_flags.unwrap_or(0) + } + + // required .Os os = 60; + + pub fn clear_os(&mut self) { + self.os = ::std::option::Option::None; + } + + pub fn has_os(&self) -> bool { + self.os.is_some() + } + + // Param is passed by value, moved + pub fn set_os(&mut self, v: Os) { + self.os = ::std::option::Option::Some(v); + } + + pub fn get_os(&self) -> Os { + self.os.unwrap_or(Os::OS_UNKNOWN) + } + + // optional uint32 os_version = 70; + + pub fn clear_os_version(&mut self) { + self.os_version = ::std::option::Option::None; + } + + pub fn has_os_version(&self) -> bool { + self.os_version.is_some() + } + + // Param is passed by value, moved + pub fn set_os_version(&mut self, v: u32) { + self.os_version = ::std::option::Option::Some(v); + } + + pub fn get_os_version(&self) -> u32 { + self.os_version.unwrap_or(0) + } + + // optional uint32 os_ext = 80; + + pub fn clear_os_ext(&mut self) { + self.os_ext = ::std::option::Option::None; + } + + pub fn has_os_ext(&self) -> bool { + self.os_ext.is_some() + } + + // Param is passed by value, moved + pub fn set_os_ext(&mut self, v: u32) { + self.os_ext = ::std::option::Option::Some(v); + } + + pub fn get_os_ext(&self) -> u32 { + self.os_ext.unwrap_or(0) + } + + // optional string system_information_string = 90; + + pub fn clear_system_information_string(&mut self) { + self.system_information_string.clear(); + } + + pub fn has_system_information_string(&self) -> bool { + self.system_information_string.is_some() + } + + // Param is passed by value, moved + pub fn set_system_information_string(&mut self, v: ::std::string::String) { + self.system_information_string = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_system_information_string(&mut self) -> &mut ::std::string::String { + if self.system_information_string.is_none() { + self.system_information_string.set_default(); + }; + self.system_information_string.as_mut().unwrap() + } + + // Take field + pub fn take_system_information_string(&mut self) -> ::std::string::String { + self.system_information_string.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_system_information_string(&self) -> &str { + match self.system_information_string.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string device_id = 100; + + pub fn clear_device_id(&mut self) { + self.device_id.clear(); + } + + pub fn has_device_id(&self) -> bool { + self.device_id.is_some() + } + + // Param is passed by value, moved + pub fn set_device_id(&mut self, v: ::std::string::String) { + self.device_id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_device_id(&mut self) -> &mut ::std::string::String { + if self.device_id.is_none() { + self.device_id.set_default(); + }; + self.device_id.as_mut().unwrap() + } + + // Take field + pub fn take_device_id(&mut self) -> ::std::string::String { + self.device_id.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_device_id(&self) -> &str { + match self.device_id.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for SystemInfo { + fn is_initialized(&self) -> bool { + if self.cpu_family.is_none() { + return false; + }; + if self.os.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.cpu_family = ::std::option::Option::Some(tmp); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.cpu_subtype = ::std::option::Option::Some(tmp); + }, + 30 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.cpu_ext = ::std::option::Option::Some(tmp); + }, + 40 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.brand = ::std::option::Option::Some(tmp); + }, + 50 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.brand_flags = ::std::option::Option::Some(tmp); + }, + 60 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.os = ::std::option::Option::Some(tmp); + }, + 70 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.os_version = ::std::option::Option::Some(tmp); + }, + 80 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.os_ext = ::std::option::Option::Some(tmp); + }, + 90 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.system_information_string)); + }, + 100 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_id)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.cpu_family { + my_size += ::protobuf::rt::enum_size(10, *value); + }; + for value in &self.cpu_subtype { + my_size += ::protobuf::rt::value_size(20, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.cpu_ext { + my_size += ::protobuf::rt::value_size(30, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.brand { + my_size += ::protobuf::rt::enum_size(40, *value); + }; + for value in &self.brand_flags { + my_size += ::protobuf::rt::value_size(50, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.os { + my_size += ::protobuf::rt::enum_size(60, *value); + }; + for value in &self.os_version { + my_size += ::protobuf::rt::value_size(70, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.os_ext { + my_size += ::protobuf::rt::value_size(80, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.system_information_string { + my_size += ::protobuf::rt::string_size(90, &value); + }; + for value in &self.device_id { + my_size += ::protobuf::rt::string_size(100, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.cpu_family { + try!(os.write_enum(10, v.value())); + }; + if let Some(v) = self.cpu_subtype { + try!(os.write_uint32(20, v)); + }; + if let Some(v) = self.cpu_ext { + try!(os.write_uint32(30, v)); + }; + if let Some(v) = self.brand { + try!(os.write_enum(40, v.value())); + }; + if let Some(v) = self.brand_flags { + try!(os.write_uint32(50, v)); + }; + if let Some(v) = self.os { + try!(os.write_enum(60, v.value())); + }; + if let Some(v) = self.os_version { + try!(os.write_uint32(70, v)); + }; + if let Some(v) = self.os_ext { + try!(os.write_uint32(80, v)); + }; + if let Some(v) = self.system_information_string.as_ref() { + try!(os.write_string(90, &v)); + }; + if let Some(v) = self.device_id.as_ref() { + try!(os.write_string(100, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for SystemInfo { + fn new() -> SystemInfo { + SystemInfo::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "cpu_family", + SystemInfo::has_cpu_family, + SystemInfo::get_cpu_family, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "cpu_subtype", + SystemInfo::has_cpu_subtype, + SystemInfo::get_cpu_subtype, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "cpu_ext", + SystemInfo::has_cpu_ext, + SystemInfo::get_cpu_ext, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "brand", + SystemInfo::has_brand, + SystemInfo::get_brand, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "brand_flags", + SystemInfo::has_brand_flags, + SystemInfo::get_brand_flags, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "os", + SystemInfo::has_os, + SystemInfo::get_os, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "os_version", + SystemInfo::has_os_version, + SystemInfo::get_os_version, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "os_ext", + SystemInfo::has_os_ext, + SystemInfo::get_os_ext, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "system_information_string", + SystemInfo::has_system_information_string, + SystemInfo::get_system_information_string, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "device_id", + SystemInfo::has_device_id, + SystemInfo::get_device_id, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SystemInfo", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for SystemInfo { + fn clear(&mut self) { + self.clear_cpu_family(); + self.clear_cpu_subtype(); + self.clear_cpu_ext(); + self.clear_brand(); + self.clear_brand_flags(); + self.clear_os(); + self.clear_os_version(); + self.clear_os_ext(); + self.clear_system_information_string(); + self.clear_device_id(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for SystemInfo { + fn eq(&self, other: &SystemInfo) -> bool { + self.cpu_family == other.cpu_family && + self.cpu_subtype == other.cpu_subtype && + self.cpu_ext == other.cpu_ext && + self.brand == other.brand && + self.brand_flags == other.brand_flags && + self.os == other.os && + self.os_version == other.os_version && + self.os_ext == other.os_ext && + self.system_information_string == other.system_information_string && + self.device_id == other.device_id && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for SystemInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LibspotifyAppKey { + // message fields + version: ::std::option::Option, + devkey: ::protobuf::SingularField<::std::vec::Vec>, + signature: ::protobuf::SingularField<::std::vec::Vec>, + useragent: ::protobuf::SingularField<::std::string::String>, + callback_hash: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LibspotifyAppKey {} + +impl LibspotifyAppKey { + pub fn new() -> LibspotifyAppKey { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LibspotifyAppKey { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LibspotifyAppKey, + }; + unsafe { + instance.get(|| { + LibspotifyAppKey { + version: ::std::option::Option::None, + devkey: ::protobuf::SingularField::none(), + signature: ::protobuf::SingularField::none(), + useragent: ::protobuf::SingularField::none(), + callback_hash: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required uint32 version = 1; + + pub fn clear_version(&mut self) { + self.version = ::std::option::Option::None; + } + + pub fn has_version(&self) -> bool { + self.version.is_some() + } + + // Param is passed by value, moved + pub fn set_version(&mut self, v: u32) { + self.version = ::std::option::Option::Some(v); + } + + pub fn get_version(&self) -> u32 { + self.version.unwrap_or(0) + } + + // required bytes devkey = 2; + + pub fn clear_devkey(&mut self) { + self.devkey.clear(); + } + + pub fn has_devkey(&self) -> bool { + self.devkey.is_some() + } + + // Param is passed by value, moved + pub fn set_devkey(&mut self, v: ::std::vec::Vec) { + self.devkey = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_devkey(&mut self) -> &mut ::std::vec::Vec { + if self.devkey.is_none() { + self.devkey.set_default(); + }; + self.devkey.as_mut().unwrap() + } + + // Take field + pub fn take_devkey(&mut self) -> ::std::vec::Vec { + self.devkey.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_devkey(&self) -> &[u8] { + match self.devkey.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required bytes signature = 3; + + pub fn clear_signature(&mut self) { + self.signature.clear(); + } + + pub fn has_signature(&self) -> bool { + self.signature.is_some() + } + + // Param is passed by value, moved + pub fn set_signature(&mut self, v: ::std::vec::Vec) { + self.signature = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec { + if self.signature.is_none() { + self.signature.set_default(); + }; + self.signature.as_mut().unwrap() + } + + // Take field + pub fn take_signature(&mut self) -> ::std::vec::Vec { + self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_signature(&self) -> &[u8] { + match self.signature.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required string useragent = 4; + + pub fn clear_useragent(&mut self) { + self.useragent.clear(); + } + + pub fn has_useragent(&self) -> bool { + self.useragent.is_some() + } + + // Param is passed by value, moved + pub fn set_useragent(&mut self, v: ::std::string::String) { + self.useragent = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_useragent(&mut self) -> &mut ::std::string::String { + if self.useragent.is_none() { + self.useragent.set_default(); + }; + self.useragent.as_mut().unwrap() + } + + // Take field + pub fn take_useragent(&mut self) -> ::std::string::String { + self.useragent.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_useragent(&self) -> &str { + match self.useragent.as_ref() { + Some(v) => &v, + None => "", + } + } + + // required bytes callback_hash = 5; + + pub fn clear_callback_hash(&mut self) { + self.callback_hash.clear(); + } + + pub fn has_callback_hash(&self) -> bool { + self.callback_hash.is_some() + } + + // Param is passed by value, moved + pub fn set_callback_hash(&mut self, v: ::std::vec::Vec) { + self.callback_hash = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_callback_hash(&mut self) -> &mut ::std::vec::Vec { + if self.callback_hash.is_none() { + self.callback_hash.set_default(); + }; + self.callback_hash.as_mut().unwrap() + } + + // Take field + pub fn take_callback_hash(&mut self) -> ::std::vec::Vec { + self.callback_hash.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_callback_hash(&self) -> &[u8] { + match self.callback_hash.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for LibspotifyAppKey { + fn is_initialized(&self) -> bool { + if self.version.is_none() { + return false; + }; + if self.devkey.is_none() { + return false; + }; + if self.signature.is_none() { + return false; + }; + if self.useragent.is_none() { + return false; + }; + if self.callback_hash.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.version = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.devkey)); + }, + 3 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)); + }, + 4 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.useragent)); + }, + 5 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.callback_hash)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.version { + my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.devkey { + my_size += ::protobuf::rt::bytes_size(2, &value); + }; + for value in &self.signature { + my_size += ::protobuf::rt::bytes_size(3, &value); + }; + for value in &self.useragent { + my_size += ::protobuf::rt::string_size(4, &value); + }; + for value in &self.callback_hash { + my_size += ::protobuf::rt::bytes_size(5, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.version { + try!(os.write_uint32(1, v)); + }; + if let Some(v) = self.devkey.as_ref() { + try!(os.write_bytes(2, &v)); + }; + if let Some(v) = self.signature.as_ref() { + try!(os.write_bytes(3, &v)); + }; + if let Some(v) = self.useragent.as_ref() { + try!(os.write_string(4, &v)); + }; + if let Some(v) = self.callback_hash.as_ref() { + try!(os.write_bytes(5, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LibspotifyAppKey { + fn new() -> LibspotifyAppKey { + LibspotifyAppKey::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "version", + LibspotifyAppKey::has_version, + LibspotifyAppKey::get_version, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "devkey", + LibspotifyAppKey::has_devkey, + LibspotifyAppKey::get_devkey, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "signature", + LibspotifyAppKey::has_signature, + LibspotifyAppKey::get_signature, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "useragent", + LibspotifyAppKey::has_useragent, + LibspotifyAppKey::get_useragent, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "callback_hash", + LibspotifyAppKey::has_callback_hash, + LibspotifyAppKey::get_callback_hash, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LibspotifyAppKey", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LibspotifyAppKey { + fn clear(&mut self) { + self.clear_version(); + self.clear_devkey(); + self.clear_signature(); + self.clear_useragent(); + self.clear_callback_hash(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LibspotifyAppKey { + fn eq(&self, other: &LibspotifyAppKey) -> bool { + self.version == other.version && + self.devkey == other.devkey && + self.signature == other.signature && + self.useragent == other.useragent && + self.callback_hash == other.callback_hash && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LibspotifyAppKey { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct ClientInfo { + // message fields + limited: ::std::option::Option, + fb: ::protobuf::SingularPtrField, + language: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ClientInfo {} + +impl ClientInfo { + pub fn new() -> ClientInfo { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ClientInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ClientInfo, + }; + unsafe { + instance.get(|| { + ClientInfo { + limited: ::std::option::Option::None, + fb: ::protobuf::SingularPtrField::none(), + language: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bool limited = 1; + + pub fn clear_limited(&mut self) { + self.limited = ::std::option::Option::None; + } + + pub fn has_limited(&self) -> bool { + self.limited.is_some() + } + + // Param is passed by value, moved + pub fn set_limited(&mut self, v: bool) { + self.limited = ::std::option::Option::Some(v); + } + + pub fn get_limited(&self) -> bool { + self.limited.unwrap_or(false) + } + + // optional .ClientInfoFacebook fb = 2; + + pub fn clear_fb(&mut self) { + self.fb.clear(); + } + + pub fn has_fb(&self) -> bool { + self.fb.is_some() + } + + // Param is passed by value, moved + pub fn set_fb(&mut self, v: ClientInfoFacebook) { + self.fb = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_fb(&mut self) -> &mut ClientInfoFacebook { + if self.fb.is_none() { + self.fb.set_default(); + }; + self.fb.as_mut().unwrap() + } + + // Take field + pub fn take_fb(&mut self) -> ClientInfoFacebook { + self.fb.take().unwrap_or_else(|| ClientInfoFacebook::new()) + } + + pub fn get_fb(&self) -> &ClientInfoFacebook { + self.fb.as_ref().unwrap_or_else(|| ClientInfoFacebook::default_instance()) + } + + // optional string language = 3; + + pub fn clear_language(&mut self) { + self.language.clear(); + } + + pub fn has_language(&self) -> bool { + self.language.is_some() + } + + // Param is passed by value, moved + pub fn set_language(&mut self, v: ::std::string::String) { + self.language = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_language(&mut self) -> &mut ::std::string::String { + if self.language.is_none() { + self.language.set_default(); + }; + self.language.as_mut().unwrap() + } + + // Take field + pub fn take_language(&mut self) -> ::std::string::String { + self.language.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_language(&self) -> &str { + match self.language.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for ClientInfo { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.limited = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fb)); + }, + 3 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.limited.is_some() { + my_size += 2; + }; + for value in &self.fb { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.language { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.limited { + try!(os.write_bool(1, v)); + }; + if let Some(v) = self.fb.as_ref() { + try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.language.as_ref() { + try!(os.write_string(3, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ClientInfo { + fn new() -> ClientInfo { + ClientInfo::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "limited", + ClientInfo::has_limited, + ClientInfo::get_limited, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "fb", + ClientInfo::has_fb, + ClientInfo::get_fb, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "language", + ClientInfo::has_language, + ClientInfo::get_language, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ClientInfo", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ClientInfo { + fn clear(&mut self) { + self.clear_limited(); + self.clear_fb(); + self.clear_language(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ClientInfo { + fn eq(&self, other: &ClientInfo) -> bool { + self.limited == other.limited && + self.fb == other.fb && + self.language == other.language && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ClientInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct ClientInfoFacebook { + // message fields + machine_id: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ClientInfoFacebook {} + +impl ClientInfoFacebook { + pub fn new() -> ClientInfoFacebook { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ClientInfoFacebook { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ClientInfoFacebook, + }; + unsafe { + instance.get(|| { + ClientInfoFacebook { + machine_id: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string machine_id = 1; + + pub fn clear_machine_id(&mut self) { + self.machine_id.clear(); + } + + pub fn has_machine_id(&self) -> bool { + self.machine_id.is_some() + } + + // Param is passed by value, moved + pub fn set_machine_id(&mut self, v: ::std::string::String) { + self.machine_id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_machine_id(&mut self) -> &mut ::std::string::String { + if self.machine_id.is_none() { + self.machine_id.set_default(); + }; + self.machine_id.as_mut().unwrap() + } + + // Take field + pub fn take_machine_id(&mut self) -> ::std::string::String { + self.machine_id.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_machine_id(&self) -> &str { + match self.machine_id.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for ClientInfoFacebook { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_id)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.machine_id { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.machine_id.as_ref() { + try!(os.write_string(1, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ClientInfoFacebook { + fn new() -> ClientInfoFacebook { + ClientInfoFacebook::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "machine_id", + ClientInfoFacebook::has_machine_id, + ClientInfoFacebook::get_machine_id, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ClientInfoFacebook", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ClientInfoFacebook { + fn clear(&mut self) { + self.clear_machine_id(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ClientInfoFacebook { + fn eq(&self, other: &ClientInfoFacebook) -> bool { + self.machine_id == other.machine_id && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ClientInfoFacebook { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct APWelcome { + // message fields + canonical_username: ::protobuf::SingularField<::std::string::String>, + account_type_logged_in: ::std::option::Option, + credentials_type_logged_in: ::std::option::Option, + reusable_auth_credentials_type: ::std::option::Option, + reusable_auth_credentials: ::protobuf::SingularField<::std::vec::Vec>, + lfs_secret: ::protobuf::SingularField<::std::vec::Vec>, + account_info: ::protobuf::SingularPtrField, + fb: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for APWelcome {} + +impl APWelcome { + pub fn new() -> APWelcome { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static APWelcome { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const APWelcome, + }; + unsafe { + instance.get(|| { + APWelcome { + canonical_username: ::protobuf::SingularField::none(), + account_type_logged_in: ::std::option::Option::None, + credentials_type_logged_in: ::std::option::Option::None, + reusable_auth_credentials_type: ::std::option::Option::None, + reusable_auth_credentials: ::protobuf::SingularField::none(), + lfs_secret: ::protobuf::SingularField::none(), + account_info: ::protobuf::SingularPtrField::none(), + fb: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required string canonical_username = 10; + + pub fn clear_canonical_username(&mut self) { + self.canonical_username.clear(); + } + + pub fn has_canonical_username(&self) -> bool { + self.canonical_username.is_some() + } + + // Param is passed by value, moved + pub fn set_canonical_username(&mut self, v: ::std::string::String) { + self.canonical_username = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_canonical_username(&mut self) -> &mut ::std::string::String { + if self.canonical_username.is_none() { + self.canonical_username.set_default(); + }; + self.canonical_username.as_mut().unwrap() + } + + // Take field + pub fn take_canonical_username(&mut self) -> ::std::string::String { + self.canonical_username.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_canonical_username(&self) -> &str { + match self.canonical_username.as_ref() { + Some(v) => &v, + None => "", + } + } + + // required .AccountType account_type_logged_in = 20; + + pub fn clear_account_type_logged_in(&mut self) { + self.account_type_logged_in = ::std::option::Option::None; + } + + pub fn has_account_type_logged_in(&self) -> bool { + self.account_type_logged_in.is_some() + } + + // Param is passed by value, moved + pub fn set_account_type_logged_in(&mut self, v: AccountType) { + self.account_type_logged_in = ::std::option::Option::Some(v); + } + + pub fn get_account_type_logged_in(&self) -> AccountType { + self.account_type_logged_in.unwrap_or(AccountType::Spotify) + } + + // required .AccountType credentials_type_logged_in = 25; + + pub fn clear_credentials_type_logged_in(&mut self) { + self.credentials_type_logged_in = ::std::option::Option::None; + } + + pub fn has_credentials_type_logged_in(&self) -> bool { + self.credentials_type_logged_in.is_some() + } + + // Param is passed by value, moved + pub fn set_credentials_type_logged_in(&mut self, v: AccountType) { + self.credentials_type_logged_in = ::std::option::Option::Some(v); + } + + pub fn get_credentials_type_logged_in(&self) -> AccountType { + self.credentials_type_logged_in.unwrap_or(AccountType::Spotify) + } + + // required .AuthenticationType reusable_auth_credentials_type = 30; + + pub fn clear_reusable_auth_credentials_type(&mut self) { + self.reusable_auth_credentials_type = ::std::option::Option::None; + } + + pub fn has_reusable_auth_credentials_type(&self) -> bool { + self.reusable_auth_credentials_type.is_some() + } + + // Param is passed by value, moved + pub fn set_reusable_auth_credentials_type(&mut self, v: AuthenticationType) { + self.reusable_auth_credentials_type = ::std::option::Option::Some(v); + } + + pub fn get_reusable_auth_credentials_type(&self) -> AuthenticationType { + self.reusable_auth_credentials_type.unwrap_or(AuthenticationType::AUTHENTICATION_USER_PASS) + } + + // required bytes reusable_auth_credentials = 40; + + pub fn clear_reusable_auth_credentials(&mut self) { + self.reusable_auth_credentials.clear(); + } + + pub fn has_reusable_auth_credentials(&self) -> bool { + self.reusable_auth_credentials.is_some() + } + + // Param is passed by value, moved + pub fn set_reusable_auth_credentials(&mut self, v: ::std::vec::Vec) { + self.reusable_auth_credentials = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_reusable_auth_credentials(&mut self) -> &mut ::std::vec::Vec { + if self.reusable_auth_credentials.is_none() { + self.reusable_auth_credentials.set_default(); + }; + self.reusable_auth_credentials.as_mut().unwrap() + } + + // Take field + pub fn take_reusable_auth_credentials(&mut self) -> ::std::vec::Vec { + self.reusable_auth_credentials.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_reusable_auth_credentials(&self) -> &[u8] { + match self.reusable_auth_credentials.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional bytes lfs_secret = 50; + + pub fn clear_lfs_secret(&mut self) { + self.lfs_secret.clear(); + } + + pub fn has_lfs_secret(&self) -> bool { + self.lfs_secret.is_some() + } + + // Param is passed by value, moved + pub fn set_lfs_secret(&mut self, v: ::std::vec::Vec) { + self.lfs_secret = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_lfs_secret(&mut self) -> &mut ::std::vec::Vec { + if self.lfs_secret.is_none() { + self.lfs_secret.set_default(); + }; + self.lfs_secret.as_mut().unwrap() + } + + // Take field + pub fn take_lfs_secret(&mut self) -> ::std::vec::Vec { + self.lfs_secret.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_lfs_secret(&self) -> &[u8] { + match self.lfs_secret.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional .AccountInfo account_info = 60; + + pub fn clear_account_info(&mut self) { + self.account_info.clear(); + } + + pub fn has_account_info(&self) -> bool { + self.account_info.is_some() + } + + // Param is passed by value, moved + pub fn set_account_info(&mut self, v: AccountInfo) { + self.account_info = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_account_info(&mut self) -> &mut AccountInfo { + if self.account_info.is_none() { + self.account_info.set_default(); + }; + self.account_info.as_mut().unwrap() + } + + // Take field + pub fn take_account_info(&mut self) -> AccountInfo { + self.account_info.take().unwrap_or_else(|| AccountInfo::new()) + } + + pub fn get_account_info(&self) -> &AccountInfo { + self.account_info.as_ref().unwrap_or_else(|| AccountInfo::default_instance()) + } + + // optional .AccountInfoFacebook fb = 70; + + pub fn clear_fb(&mut self) { + self.fb.clear(); + } + + pub fn has_fb(&self) -> bool { + self.fb.is_some() + } + + // Param is passed by value, moved + pub fn set_fb(&mut self, v: AccountInfoFacebook) { + self.fb = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_fb(&mut self) -> &mut AccountInfoFacebook { + if self.fb.is_none() { + self.fb.set_default(); + }; + self.fb.as_mut().unwrap() + } + + // Take field + pub fn take_fb(&mut self) -> AccountInfoFacebook { + self.fb.take().unwrap_or_else(|| AccountInfoFacebook::new()) + } + + pub fn get_fb(&self) -> &AccountInfoFacebook { + self.fb.as_ref().unwrap_or_else(|| AccountInfoFacebook::default_instance()) + } +} + +impl ::protobuf::Message for APWelcome { + fn is_initialized(&self) -> bool { + if self.canonical_username.is_none() { + return false; + }; + if self.account_type_logged_in.is_none() { + return false; + }; + if self.credentials_type_logged_in.is_none() { + return false; + }; + if self.reusable_auth_credentials_type.is_none() { + return false; + }; + if self.reusable_auth_credentials.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.canonical_username)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.account_type_logged_in = ::std::option::Option::Some(tmp); + }, + 25 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.credentials_type_logged_in = ::std::option::Option::Some(tmp); + }, + 30 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.reusable_auth_credentials_type = ::std::option::Option::Some(tmp); + }, + 40 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.reusable_auth_credentials)); + }, + 50 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.lfs_secret)); + }, + 60 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.account_info)); + }, + 70 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fb)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.canonical_username { + my_size += ::protobuf::rt::string_size(10, &value); + }; + for value in &self.account_type_logged_in { + my_size += ::protobuf::rt::enum_size(20, *value); + }; + for value in &self.credentials_type_logged_in { + my_size += ::protobuf::rt::enum_size(25, *value); + }; + for value in &self.reusable_auth_credentials_type { + my_size += ::protobuf::rt::enum_size(30, *value); + }; + for value in &self.reusable_auth_credentials { + my_size += ::protobuf::rt::bytes_size(40, &value); + }; + for value in &self.lfs_secret { + my_size += ::protobuf::rt::bytes_size(50, &value); + }; + for value in &self.account_info { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.fb { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.canonical_username.as_ref() { + try!(os.write_string(10, &v)); + }; + if let Some(v) = self.account_type_logged_in { + try!(os.write_enum(20, v.value())); + }; + if let Some(v) = self.credentials_type_logged_in { + try!(os.write_enum(25, v.value())); + }; + if let Some(v) = self.reusable_auth_credentials_type { + try!(os.write_enum(30, v.value())); + }; + if let Some(v) = self.reusable_auth_credentials.as_ref() { + try!(os.write_bytes(40, &v)); + }; + if let Some(v) = self.lfs_secret.as_ref() { + try!(os.write_bytes(50, &v)); + }; + if let Some(v) = self.account_info.as_ref() { + try!(os.write_tag(60, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.fb.as_ref() { + try!(os.write_tag(70, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for APWelcome { + fn new() -> APWelcome { + APWelcome::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "canonical_username", + APWelcome::has_canonical_username, + APWelcome::get_canonical_username, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "account_type_logged_in", + APWelcome::has_account_type_logged_in, + APWelcome::get_account_type_logged_in, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "credentials_type_logged_in", + APWelcome::has_credentials_type_logged_in, + APWelcome::get_credentials_type_logged_in, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "reusable_auth_credentials_type", + APWelcome::has_reusable_auth_credentials_type, + APWelcome::get_reusable_auth_credentials_type, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "reusable_auth_credentials", + APWelcome::has_reusable_auth_credentials, + APWelcome::get_reusable_auth_credentials, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "lfs_secret", + APWelcome::has_lfs_secret, + APWelcome::get_lfs_secret, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "account_info", + APWelcome::has_account_info, + APWelcome::get_account_info, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "fb", + APWelcome::has_fb, + APWelcome::get_fb, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "APWelcome", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for APWelcome { + fn clear(&mut self) { + self.clear_canonical_username(); + self.clear_account_type_logged_in(); + self.clear_credentials_type_logged_in(); + self.clear_reusable_auth_credentials_type(); + self.clear_reusable_auth_credentials(); + self.clear_lfs_secret(); + self.clear_account_info(); + self.clear_fb(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for APWelcome { + fn eq(&self, other: &APWelcome) -> bool { + self.canonical_username == other.canonical_username && + self.account_type_logged_in == other.account_type_logged_in && + self.credentials_type_logged_in == other.credentials_type_logged_in && + self.reusable_auth_credentials_type == other.reusable_auth_credentials_type && + self.reusable_auth_credentials == other.reusable_auth_credentials && + self.lfs_secret == other.lfs_secret && + self.account_info == other.account_info && + self.fb == other.fb && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for APWelcome { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct AccountInfo { + // message fields + spotify: ::protobuf::SingularPtrField, + facebook: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for AccountInfo {} + +impl AccountInfo { + pub fn new() -> AccountInfo { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static AccountInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AccountInfo, + }; + unsafe { + instance.get(|| { + AccountInfo { + spotify: ::protobuf::SingularPtrField::none(), + facebook: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .AccountInfoSpotify spotify = 1; + + pub fn clear_spotify(&mut self) { + self.spotify.clear(); + } + + pub fn has_spotify(&self) -> bool { + self.spotify.is_some() + } + + // Param is passed by value, moved + pub fn set_spotify(&mut self, v: AccountInfoSpotify) { + self.spotify = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_spotify(&mut self) -> &mut AccountInfoSpotify { + if self.spotify.is_none() { + self.spotify.set_default(); + }; + self.spotify.as_mut().unwrap() + } + + // Take field + pub fn take_spotify(&mut self) -> AccountInfoSpotify { + self.spotify.take().unwrap_or_else(|| AccountInfoSpotify::new()) + } + + pub fn get_spotify(&self) -> &AccountInfoSpotify { + self.spotify.as_ref().unwrap_or_else(|| AccountInfoSpotify::default_instance()) + } + + // optional .AccountInfoFacebook facebook = 2; + + pub fn clear_facebook(&mut self) { + self.facebook.clear(); + } + + pub fn has_facebook(&self) -> bool { + self.facebook.is_some() + } + + // Param is passed by value, moved + pub fn set_facebook(&mut self, v: AccountInfoFacebook) { + self.facebook = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_facebook(&mut self) -> &mut AccountInfoFacebook { + if self.facebook.is_none() { + self.facebook.set_default(); + }; + self.facebook.as_mut().unwrap() + } + + // Take field + pub fn take_facebook(&mut self) -> AccountInfoFacebook { + self.facebook.take().unwrap_or_else(|| AccountInfoFacebook::new()) + } + + pub fn get_facebook(&self) -> &AccountInfoFacebook { + self.facebook.as_ref().unwrap_or_else(|| AccountInfoFacebook::default_instance()) + } +} + +impl ::protobuf::Message for AccountInfo { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.spotify)); + }, + 2 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.facebook)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.spotify { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.facebook { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.spotify.as_ref() { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.facebook.as_ref() { + try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for AccountInfo { + fn new() -> AccountInfo { + AccountInfo::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "spotify", + AccountInfo::has_spotify, + AccountInfo::get_spotify, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "facebook", + AccountInfo::has_facebook, + AccountInfo::get_facebook, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AccountInfo", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for AccountInfo { + fn clear(&mut self) { + self.clear_spotify(); + self.clear_facebook(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for AccountInfo { + fn eq(&self, other: &AccountInfo) -> bool { + self.spotify == other.spotify && + self.facebook == other.facebook && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for AccountInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct AccountInfoSpotify { + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for AccountInfoSpotify {} + +impl AccountInfoSpotify { + pub fn new() -> AccountInfoSpotify { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static AccountInfoSpotify { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AccountInfoSpotify, + }; + unsafe { + instance.get(|| { + AccountInfoSpotify { + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } +} + +impl ::protobuf::Message for AccountInfoSpotify { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for AccountInfoSpotify { + fn new() -> AccountInfoSpotify { + AccountInfoSpotify::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "AccountInfoSpotify", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for AccountInfoSpotify { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for AccountInfoSpotify { + fn eq(&self, other: &AccountInfoSpotify) -> bool { + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for AccountInfoSpotify { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct AccountInfoFacebook { + // message fields + access_token: ::protobuf::SingularField<::std::string::String>, + machine_id: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for AccountInfoFacebook {} + +impl AccountInfoFacebook { + pub fn new() -> AccountInfoFacebook { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static AccountInfoFacebook { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AccountInfoFacebook, + }; + unsafe { + instance.get(|| { + AccountInfoFacebook { + access_token: ::protobuf::SingularField::none(), + machine_id: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string access_token = 1; + + pub fn clear_access_token(&mut self) { + self.access_token.clear(); + } + + pub fn has_access_token(&self) -> bool { + self.access_token.is_some() + } + + // Param is passed by value, moved + pub fn set_access_token(&mut self, v: ::std::string::String) { + self.access_token = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_access_token(&mut self) -> &mut ::std::string::String { + if self.access_token.is_none() { + self.access_token.set_default(); + }; + self.access_token.as_mut().unwrap() + } + + // Take field + pub fn take_access_token(&mut self) -> ::std::string::String { + self.access_token.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_access_token(&self) -> &str { + match self.access_token.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string machine_id = 2; + + pub fn clear_machine_id(&mut self) { + self.machine_id.clear(); + } + + pub fn has_machine_id(&self) -> bool { + self.machine_id.is_some() + } + + // Param is passed by value, moved + pub fn set_machine_id(&mut self, v: ::std::string::String) { + self.machine_id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_machine_id(&mut self) -> &mut ::std::string::String { + if self.machine_id.is_none() { + self.machine_id.set_default(); + }; + self.machine_id.as_mut().unwrap() + } + + // Take field + pub fn take_machine_id(&mut self) -> ::std::string::String { + self.machine_id.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_machine_id(&self) -> &str { + match self.machine_id.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for AccountInfoFacebook { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.access_token)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_id)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.access_token { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.machine_id { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.access_token.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.machine_id.as_ref() { + try!(os.write_string(2, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for AccountInfoFacebook { + fn new() -> AccountInfoFacebook { + AccountInfoFacebook::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "access_token", + AccountInfoFacebook::has_access_token, + AccountInfoFacebook::get_access_token, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "machine_id", + AccountInfoFacebook::has_machine_id, + AccountInfoFacebook::get_machine_id, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AccountInfoFacebook", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for AccountInfoFacebook { + fn clear(&mut self) { + self.clear_access_token(); + self.clear_machine_id(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for AccountInfoFacebook { + fn eq(&self, other: &AccountInfoFacebook) -> bool { + self.access_token == other.access_token && + self.machine_id == other.machine_id && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for AccountInfoFacebook { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum AuthenticationType { + AUTHENTICATION_USER_PASS = 0, + AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS = 1, + AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS = 2, + AUTHENTICATION_SPOTIFY_TOKEN = 3, + AUTHENTICATION_FACEBOOK_TOKEN = 4, +} + +impl ::protobuf::ProtobufEnum for AuthenticationType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_USER_PASS), + 1 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS), + 2 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS), + 3 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_SPOTIFY_TOKEN), + 4 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_FACEBOOK_TOKEN), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [AuthenticationType] = &[ + AuthenticationType::AUTHENTICATION_USER_PASS, + AuthenticationType::AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS, + AuthenticationType::AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS, + AuthenticationType::AUTHENTICATION_SPOTIFY_TOKEN, + AuthenticationType::AUTHENTICATION_FACEBOOK_TOKEN, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("AuthenticationType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for AuthenticationType { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum AccountCreation { + ACCOUNT_CREATION_ALWAYS_PROMPT = 1, + ACCOUNT_CREATION_ALWAYS_CREATE = 3, +} + +impl ::protobuf::ProtobufEnum for AccountCreation { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT), + 3 => ::std::option::Option::Some(AccountCreation::ACCOUNT_CREATION_ALWAYS_CREATE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [AccountCreation] = &[ + AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT, + AccountCreation::ACCOUNT_CREATION_ALWAYS_CREATE, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("AccountCreation", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for AccountCreation { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum CpuFamily { + CPU_UNKNOWN = 0, + CPU_X86 = 1, + CPU_X86_64 = 2, + CPU_PPC = 3, + CPU_PPC_64 = 4, + CPU_ARM = 5, + CPU_IA64 = 6, + CPU_SH = 7, + CPU_MIPS = 8, + CPU_BLACKFIN = 9, +} + +impl ::protobuf::ProtobufEnum for CpuFamily { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(CpuFamily::CPU_UNKNOWN), + 1 => ::std::option::Option::Some(CpuFamily::CPU_X86), + 2 => ::std::option::Option::Some(CpuFamily::CPU_X86_64), + 3 => ::std::option::Option::Some(CpuFamily::CPU_PPC), + 4 => ::std::option::Option::Some(CpuFamily::CPU_PPC_64), + 5 => ::std::option::Option::Some(CpuFamily::CPU_ARM), + 6 => ::std::option::Option::Some(CpuFamily::CPU_IA64), + 7 => ::std::option::Option::Some(CpuFamily::CPU_SH), + 8 => ::std::option::Option::Some(CpuFamily::CPU_MIPS), + 9 => ::std::option::Option::Some(CpuFamily::CPU_BLACKFIN), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [CpuFamily] = &[ + CpuFamily::CPU_UNKNOWN, + CpuFamily::CPU_X86, + CpuFamily::CPU_X86_64, + CpuFamily::CPU_PPC, + CpuFamily::CPU_PPC_64, + CpuFamily::CPU_ARM, + CpuFamily::CPU_IA64, + CpuFamily::CPU_SH, + CpuFamily::CPU_MIPS, + CpuFamily::CPU_BLACKFIN, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("CpuFamily", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for CpuFamily { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Brand { + BRAND_UNBRANDED = 0, + BRAND_INQ = 1, + BRAND_HTC = 2, + BRAND_NOKIA = 3, +} + +impl ::protobuf::ProtobufEnum for Brand { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Brand::BRAND_UNBRANDED), + 1 => ::std::option::Option::Some(Brand::BRAND_INQ), + 2 => ::std::option::Option::Some(Brand::BRAND_HTC), + 3 => ::std::option::Option::Some(Brand::BRAND_NOKIA), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Brand] = &[ + Brand::BRAND_UNBRANDED, + Brand::BRAND_INQ, + Brand::BRAND_HTC, + Brand::BRAND_NOKIA, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Brand", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Brand { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Os { + OS_UNKNOWN = 0, + OS_WINDOWS = 1, + OS_OSX = 2, + OS_IPHONE = 3, + OS_S60 = 4, + OS_LINUX = 5, + OS_WINDOWS_CE = 6, + OS_ANDROID = 7, + OS_PALM = 8, + OS_FREEBSD = 9, + OS_BLACKBERRY = 10, + OS_SONOS = 11, + OS_LOGITECH = 12, + OS_WP7 = 13, + OS_ONKYO = 14, + OS_PHILIPS = 15, + OS_WD = 16, + OS_VOLVO = 17, + OS_TIVO = 18, + OS_AWOX = 19, + OS_MEEGO = 20, + OS_QNXNTO = 21, + OS_BCO = 22, +} + +impl ::protobuf::ProtobufEnum for Os { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Os::OS_UNKNOWN), + 1 => ::std::option::Option::Some(Os::OS_WINDOWS), + 2 => ::std::option::Option::Some(Os::OS_OSX), + 3 => ::std::option::Option::Some(Os::OS_IPHONE), + 4 => ::std::option::Option::Some(Os::OS_S60), + 5 => ::std::option::Option::Some(Os::OS_LINUX), + 6 => ::std::option::Option::Some(Os::OS_WINDOWS_CE), + 7 => ::std::option::Option::Some(Os::OS_ANDROID), + 8 => ::std::option::Option::Some(Os::OS_PALM), + 9 => ::std::option::Option::Some(Os::OS_FREEBSD), + 10 => ::std::option::Option::Some(Os::OS_BLACKBERRY), + 11 => ::std::option::Option::Some(Os::OS_SONOS), + 12 => ::std::option::Option::Some(Os::OS_LOGITECH), + 13 => ::std::option::Option::Some(Os::OS_WP7), + 14 => ::std::option::Option::Some(Os::OS_ONKYO), + 15 => ::std::option::Option::Some(Os::OS_PHILIPS), + 16 => ::std::option::Option::Some(Os::OS_WD), + 17 => ::std::option::Option::Some(Os::OS_VOLVO), + 18 => ::std::option::Option::Some(Os::OS_TIVO), + 19 => ::std::option::Option::Some(Os::OS_AWOX), + 20 => ::std::option::Option::Some(Os::OS_MEEGO), + 21 => ::std::option::Option::Some(Os::OS_QNXNTO), + 22 => ::std::option::Option::Some(Os::OS_BCO), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Os] = &[ + Os::OS_UNKNOWN, + Os::OS_WINDOWS, + Os::OS_OSX, + Os::OS_IPHONE, + Os::OS_S60, + Os::OS_LINUX, + Os::OS_WINDOWS_CE, + Os::OS_ANDROID, + Os::OS_PALM, + Os::OS_FREEBSD, + Os::OS_BLACKBERRY, + Os::OS_SONOS, + Os::OS_LOGITECH, + Os::OS_WP7, + Os::OS_ONKYO, + Os::OS_PHILIPS, + Os::OS_WD, + Os::OS_VOLVO, + Os::OS_TIVO, + Os::OS_AWOX, + Os::OS_MEEGO, + Os::OS_QNXNTO, + Os::OS_BCO, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Os", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Os { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum AccountType { + Spotify = 0, + Facebook = 1, +} + +impl ::protobuf::ProtobufEnum for AccountType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(AccountType::Spotify), + 1 => ::std::option::Option::Some(AccountType::Facebook), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [AccountType] = &[ + AccountType::Spotify, + AccountType::Facebook, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("AccountType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for AccountType { +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x14, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xec, 0x03, 0x0a, 0x17, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x65, 0x64, 0x12, 0x3e, 0x0a, 0x11, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x5f, 0x63, 0x72, 0x65, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x11, 0x2e, + 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, + 0x52, 0x10, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, + 0x6c, 0x73, 0x12, 0x3b, 0x0a, 0x10, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x41, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x4c, 0x0a, 0x14, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x5f, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, + 0x70, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, + 0x0b, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x28, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x55, + 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, + 0x12, 0x2c, 0x0a, 0x0b, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, + 0x32, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x25, + 0x0a, 0x0e, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, + 0x18, 0x3c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x46, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x29, 0x0a, 0x06, + 0x61, 0x70, 0x70, 0x6b, 0x65, 0x79, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x4c, + 0x69, 0x62, 0x73, 0x70, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x41, 0x70, 0x70, 0x4b, 0x65, 0x79, 0x52, + 0x06, 0x61, 0x70, 0x70, 0x6b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x72, 0x0a, 0x10, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, + 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x75, 0x73, 0x65, + 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, 0x73, 0x65, + 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x03, 0x74, 0x79, 0x70, 0x18, 0x14, 0x20, 0x02, + 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x03, 0x74, 0x79, 0x70, 0x12, 0x1b, 0x0a, 0x09, + 0x61, 0x75, 0x74, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x08, 0x61, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x22, 0x8c, 0x01, 0x0a, 0x18, 0x46, 0x69, + 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x05, 0x67, 0x72, 0x61, 0x69, 0x6e, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, + 0x69, 0x6e, 0x74, 0x47, 0x72, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x05, 0x67, 0x72, 0x61, 0x69, 0x6e, 0x12, 0x3f, 0x0a, 0x0b, 0x68, 0x6d, 0x61, 0x63, 0x5f, + 0x72, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x46, + 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x48, 0x6d, 0x61, 0x63, 0x52, 0x69, + 0x70, 0x65, 0x6d, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x68, 0x6d, + 0x61, 0x63, 0x52, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x22, 0x3f, 0x0a, 0x18, 0x46, 0x69, 0x6e, 0x67, + 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x47, 0x72, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, + 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x0c, 0x65, 0x6e, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x22, 0x33, 0x0a, 0x1d, 0x46, 0x69, 0x6e, + 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x48, 0x6d, 0x61, 0x63, 0x52, 0x69, 0x70, 0x65, + 0x6d, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6d, + 0x61, 0x63, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x6d, 0x61, 0x63, 0x22, 0x75, + 0x0a, 0x0f, 0x50, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x55, 0x6e, 0x69, 0x6f, + 0x6e, 0x12, 0x33, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, + 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x0a, 0x6f, 0x6c, 0x64, 0x5f, 0x74, 0x69, + 0x63, 0x6b, 0x65, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x50, 0x65, 0x65, + 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x4f, 0x6c, 0x64, 0x52, 0x09, 0x6f, 0x6c, 0x64, 0x54, + 0x69, 0x63, 0x6b, 0x65, 0x74, 0x22, 0x34, 0x0a, 0x13, 0x50, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, + 0x6b, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, + 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x22, 0x64, 0x0a, 0x0d, 0x50, + 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x4f, 0x6c, 0x64, 0x12, 0x1f, 0x0a, 0x0b, + 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x02, 0x28, + 0x0c, 0x52, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x32, 0x0a, + 0x15, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x73, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x13, 0x70, 0x65, + 0x65, 0x72, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x22, 0xd4, 0x02, 0x0a, 0x0a, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x29, 0x0a, 0x0a, 0x63, 0x70, 0x75, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x0a, + 0x20, 0x02, 0x28, 0x0e, 0x32, 0x0a, 0x2e, 0x43, 0x70, 0x75, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, + 0x52, 0x09, 0x63, 0x70, 0x75, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x63, + 0x70, 0x75, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0a, 0x63, 0x70, 0x75, 0x53, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, + 0x63, 0x70, 0x75, 0x5f, 0x65, 0x78, 0x74, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x63, + 0x70, 0x75, 0x45, 0x78, 0x74, 0x12, 0x1c, 0x0a, 0x05, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x18, 0x28, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x06, 0x2e, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x52, 0x05, 0x62, 0x72, + 0x61, 0x6e, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x5f, 0x66, 0x6c, 0x61, + 0x67, 0x73, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x46, + 0x6c, 0x61, 0x67, 0x73, 0x12, 0x13, 0x0a, 0x02, 0x6f, 0x73, 0x18, 0x3c, 0x20, 0x02, 0x28, 0x0e, + 0x32, 0x03, 0x2e, 0x4f, 0x73, 0x52, 0x02, 0x6f, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x73, 0x5f, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x6f, + 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x73, 0x5f, 0x65, + 0x78, 0x74, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6f, 0x73, 0x45, 0x78, 0x74, 0x12, + 0x3a, 0x0a, 0x19, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x5a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x17, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x64, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64, 0x22, 0xa5, 0x01, 0x0a, 0x10, 0x4c, 0x69, 0x62, + 0x73, 0x70, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x41, 0x70, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0d, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x6b, 0x65, + 0x79, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x65, 0x76, 0x6b, 0x65, 0x79, 0x12, + 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x02, + 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x75, 0x73, 0x65, 0x72, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x02, 0x28, 0x09, + 0x52, 0x09, 0x75, 0x73, 0x65, 0x72, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x63, + 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x02, + 0x28, 0x0c, 0x52, 0x0c, 0x63, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, + 0x22, 0x67, 0x0a, 0x0a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, + 0x0a, 0x07, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x07, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x02, 0x66, 0x62, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x02, 0x66, 0x62, 0x12, 0x1a, 0x0a, + 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x22, 0x33, 0x0a, 0x12, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x12, + 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x22, 0xd4, + 0x03, 0x0a, 0x09, 0x41, 0x50, 0x57, 0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x12, + 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x09, 0x52, 0x11, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, + 0x63, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x16, 0x61, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6c, 0x6f, 0x67, 0x67, + 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x41, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x13, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x49, 0x6e, 0x12, 0x49, + 0x0a, 0x1a, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x5f, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x18, 0x19, 0x20, 0x02, + 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x17, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x54, 0x79, 0x70, + 0x65, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x49, 0x6e, 0x12, 0x58, 0x0a, 0x1e, 0x72, 0x65, 0x75, + 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x1e, 0x20, 0x02, 0x28, + 0x0e, 0x32, 0x13, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x1b, 0x72, 0x65, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, + 0x41, 0x75, 0x74, 0x68, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x72, 0x65, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x61, 0x75, 0x74, 0x68, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, + 0x18, 0x28, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x17, 0x72, 0x65, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, + 0x41, 0x75, 0x74, 0x68, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, + 0x1d, 0x0a, 0x0a, 0x6c, 0x66, 0x73, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x18, 0x32, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6c, 0x66, 0x73, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x2f, + 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x3c, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x24, 0x0a, 0x02, 0x66, 0x62, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x41, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, + 0x6b, 0x52, 0x02, 0x66, 0x62, 0x22, 0x6e, 0x0a, 0x0b, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x07, 0x73, 0x70, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x53, 0x70, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x52, 0x07, 0x73, 0x70, 0x6f, 0x74, + 0x69, 0x66, 0x79, 0x12, 0x30, 0x0a, 0x08, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x08, 0x66, 0x61, 0x63, + 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x22, 0x14, 0x0a, 0x12, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x53, 0x70, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x22, 0x57, 0x0a, 0x13, 0x41, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, + 0x6f, 0x6b, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, + 0x6e, 0x65, 0x49, 0x64, 0x2a, 0xd6, 0x01, 0x0a, 0x12, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x18, 0x41, + 0x55, 0x54, 0x48, 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x53, + 0x45, 0x52, 0x5f, 0x50, 0x41, 0x53, 0x53, 0x10, 0x00, 0x12, 0x2d, 0x0a, 0x29, 0x41, 0x55, 0x54, + 0x48, 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x4f, 0x52, + 0x45, 0x44, 0x5f, 0x53, 0x50, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, + 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x10, 0x01, 0x12, 0x2e, 0x0a, 0x2a, 0x41, 0x55, 0x54, 0x48, + 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x45, + 0x44, 0x5f, 0x46, 0x41, 0x43, 0x45, 0x42, 0x4f, 0x4f, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, + 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x10, 0x02, 0x12, 0x20, 0x0a, 0x1c, 0x41, 0x55, 0x54, 0x48, + 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x50, 0x4f, 0x54, 0x49, + 0x46, 0x59, 0x5f, 0x54, 0x4f, 0x4b, 0x45, 0x4e, 0x10, 0x03, 0x12, 0x21, 0x0a, 0x1d, 0x41, 0x55, + 0x54, 0x48, 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x43, + 0x45, 0x42, 0x4f, 0x4f, 0x4b, 0x5f, 0x54, 0x4f, 0x4b, 0x45, 0x4e, 0x10, 0x04, 0x2a, 0x59, 0x0a, + 0x0f, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x4d, + 0x50, 0x54, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x5f, + 0x43, 0x52, 0x45, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x5f, + 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x03, 0x2a, 0x9d, 0x01, 0x0a, 0x09, 0x43, 0x70, 0x75, + 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x50, 0x55, 0x5f, 0x55, 0x4e, + 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x50, 0x55, 0x5f, 0x58, + 0x38, 0x36, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x50, 0x55, 0x5f, 0x58, 0x38, 0x36, 0x5f, + 0x36, 0x34, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x50, 0x55, 0x5f, 0x50, 0x50, 0x43, 0x10, + 0x03, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x50, 0x55, 0x5f, 0x50, 0x50, 0x43, 0x5f, 0x36, 0x34, 0x10, + 0x04, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x50, 0x55, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x05, 0x12, 0x0c, + 0x0a, 0x08, 0x43, 0x50, 0x55, 0x5f, 0x49, 0x41, 0x36, 0x34, 0x10, 0x06, 0x12, 0x0a, 0x0a, 0x06, + 0x43, 0x50, 0x55, 0x5f, 0x53, 0x48, 0x10, 0x07, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x50, 0x55, 0x5f, + 0x4d, 0x49, 0x50, 0x53, 0x10, 0x08, 0x12, 0x10, 0x0a, 0x0c, 0x43, 0x50, 0x55, 0x5f, 0x42, 0x4c, + 0x41, 0x43, 0x4b, 0x46, 0x49, 0x4e, 0x10, 0x09, 0x2a, 0x4b, 0x0a, 0x05, 0x42, 0x72, 0x61, 0x6e, + 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x42, 0x52, 0x41, 0x4e, 0x44, 0x5f, 0x55, 0x4e, 0x42, 0x52, 0x41, + 0x4e, 0x44, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x42, 0x52, 0x41, 0x4e, 0x44, 0x5f, + 0x49, 0x4e, 0x51, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x42, 0x52, 0x41, 0x4e, 0x44, 0x5f, 0x48, + 0x54, 0x43, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x42, 0x52, 0x41, 0x4e, 0x44, 0x5f, 0x4e, 0x4f, + 0x4b, 0x49, 0x41, 0x10, 0x03, 0x2a, 0xd1, 0x02, 0x0a, 0x02, 0x4f, 0x73, 0x12, 0x0e, 0x0a, 0x0a, + 0x4f, 0x53, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, + 0x4f, 0x53, 0x5f, 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x53, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, + 0x4f, 0x53, 0x5f, 0x4f, 0x53, 0x58, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x4f, 0x53, 0x5f, 0x49, + 0x50, 0x48, 0x4f, 0x4e, 0x45, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x53, 0x5f, 0x53, 0x36, + 0x30, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x53, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x10, + 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x53, 0x5f, 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x53, 0x5f, + 0x43, 0x45, 0x10, 0x06, 0x12, 0x0e, 0x0a, 0x0a, 0x4f, 0x53, 0x5f, 0x41, 0x4e, 0x44, 0x52, 0x4f, + 0x49, 0x44, 0x10, 0x07, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x53, 0x5f, 0x50, 0x41, 0x4c, 0x4d, 0x10, + 0x08, 0x12, 0x0e, 0x0a, 0x0a, 0x4f, 0x53, 0x5f, 0x46, 0x52, 0x45, 0x45, 0x42, 0x53, 0x44, 0x10, + 0x09, 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x53, 0x5f, 0x42, 0x4c, 0x41, 0x43, 0x4b, 0x42, 0x45, 0x52, + 0x52, 0x59, 0x10, 0x0a, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x53, 0x5f, 0x53, 0x4f, 0x4e, 0x4f, 0x53, + 0x10, 0x0b, 0x12, 0x0f, 0x0a, 0x0b, 0x4f, 0x53, 0x5f, 0x4c, 0x4f, 0x47, 0x49, 0x54, 0x45, 0x43, + 0x48, 0x10, 0x0c, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x53, 0x5f, 0x57, 0x50, 0x37, 0x10, 0x0d, 0x12, + 0x0c, 0x0a, 0x08, 0x4f, 0x53, 0x5f, 0x4f, 0x4e, 0x4b, 0x59, 0x4f, 0x10, 0x0e, 0x12, 0x0e, 0x0a, + 0x0a, 0x4f, 0x53, 0x5f, 0x50, 0x48, 0x49, 0x4c, 0x49, 0x50, 0x53, 0x10, 0x0f, 0x12, 0x09, 0x0a, + 0x05, 0x4f, 0x53, 0x5f, 0x57, 0x44, 0x10, 0x10, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x53, 0x5f, 0x56, + 0x4f, 0x4c, 0x56, 0x4f, 0x10, 0x11, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x53, 0x5f, 0x54, 0x49, 0x56, + 0x4f, 0x10, 0x12, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x53, 0x5f, 0x41, 0x57, 0x4f, 0x58, 0x10, 0x13, + 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x53, 0x5f, 0x4d, 0x45, 0x45, 0x47, 0x4f, 0x10, 0x14, 0x12, 0x0d, + 0x0a, 0x09, 0x4f, 0x53, 0x5f, 0x51, 0x4e, 0x58, 0x4e, 0x54, 0x4f, 0x10, 0x15, 0x12, 0x0a, 0x0a, + 0x06, 0x4f, 0x53, 0x5f, 0x42, 0x43, 0x4f, 0x10, 0x16, 0x2a, 0x28, 0x0a, 0x0b, 0x41, 0x63, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x70, 0x6f, 0x74, + 0x69, 0x66, 0x79, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, + 0x6b, 0x10, 0x01, 0x4a, 0xee, 0x2f, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xa4, 0x01, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x02, 0x00, 0x0c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, + 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x36, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x03, 0x0d, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x03, 0x1e, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x03, 0x32, 0x35, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x04, 0x04, 0x35, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x04, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x04, 0x0d, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x04, 0x1d, 0x2d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x04, 0x30, 0x34, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x05, 0x04, 0x42, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x05, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x05, 0x0d, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x05, + 0x26, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x05, 0x3d, 0x41, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x06, 0x04, 0x30, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x04, 0x12, 0x03, 0x06, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x06, 0x0d, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x06, 0x1d, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x06, 0x2b, 0x2f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x07, + 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x04, 0x12, 0x03, 0x07, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x07, 0x0d, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x07, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x07, 0x26, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x05, 0x12, 0x03, 0x08, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x04, + 0x12, 0x03, 0x08, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x05, 0x12, 0x03, + 0x08, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x08, 0x14, + 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x08, 0x25, 0x29, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x09, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x06, 0x04, 0x12, 0x03, 0x09, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x06, 0x05, 0x12, 0x03, 0x09, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, + 0x01, 0x12, 0x03, 0x09, 0x14, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, + 0x03, 0x09, 0x25, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x0a, 0x04, + 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x04, 0x12, 0x03, 0x0a, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x0a, 0x0d, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x0a, 0x1e, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x07, 0x03, 0x12, 0x03, 0x0a, 0x27, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x08, 0x12, 0x03, 0x0b, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x04, 0x12, + 0x03, 0x0b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x06, 0x12, 0x03, 0x0b, + 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x0b, 0x18, 0x23, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x0b, 0x26, 0x2a, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x0e, 0x00, 0x12, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x0e, 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x0f, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x0f, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0f, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x10, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x04, 0x12, 0x03, 0x10, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x10, 0x0d, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, + 0x20, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x26, 0x2a, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x11, 0x04, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x11, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x11, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x11, 0x13, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x11, 0x1f, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x14, 0x00, 0x1a, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x14, 0x05, 0x17, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x15, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x15, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x02, 0x12, 0x03, 0x15, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x16, 0x04, 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x16, 0x04, + 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x16, 0x30, 0x33, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x17, 0x04, 0x35, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x17, 0x31, 0x34, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, + 0x12, 0x03, 0x18, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x18, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x18, 0x23, + 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x19, 0x04, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x19, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x19, 0x24, 0x27, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, + 0x12, 0x04, 0x1c, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x1c, + 0x05, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x04, 0x29, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1d, 0x04, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x01, 0x02, 0x00, 0x02, 0x12, 0x03, 0x1d, 0x25, 0x28, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x1e, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1e, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x1e, 0x25, 0x28, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x21, 0x00, 0x24, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x21, 0x08, 0x20, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x22, 0x04, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x22, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x22, 0x0d, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x22, 0x26, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x2e, + 0x31, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x23, 0x04, 0x3e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x23, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x23, 0x0d, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x23, 0x2b, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x23, 0x39, 0x3d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x26, 0x00, + 0x28, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x26, 0x08, 0x20, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x27, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x27, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x27, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x27, 0x13, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x27, 0x23, 0x26, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x2a, 0x00, 0x2c, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x2b, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x2b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x2b, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, + 0x13, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x1a, 0x1d, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x2e, 0x00, 0x31, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x05, 0x01, 0x12, 0x03, 0x2e, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, + 0x12, 0x03, 0x2f, 0x04, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x2f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2f, 0x0d, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2f, 0x21, 0x2b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2f, 0x2e, 0x31, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x30, 0x04, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x30, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x30, 0x0d, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x30, 0x1b, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x30, + 0x28, 0x2c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x33, 0x00, 0x35, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x33, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x00, 0x12, 0x03, 0x34, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x34, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x34, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x13, + 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x34, 0x20, 0x23, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x37, 0x00, 0x3a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x07, 0x01, 0x12, 0x03, 0x37, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, + 0x03, 0x38, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x03, 0x38, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x03, 0x38, 0x0d, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x13, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x39, 0x04, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x01, 0x04, 0x12, 0x03, 0x39, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x39, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x39, 0x13, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x39, 0x2b, + 0x2f, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x3c, 0x00, 0x47, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x3c, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x00, 0x12, 0x03, 0x3d, 0x04, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x3d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x03, 0x3d, + 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3d, 0x17, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3d, 0x24, 0x27, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x03, 0x3e, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x04, 0x12, 0x03, 0x3e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x3e, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x3e, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x3e, 0x22, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x03, 0x3f, 0x04, 0x23, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x04, 0x12, 0x03, 0x3f, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, 0x03, 0x3f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x3f, 0x1e, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, + 0x12, 0x03, 0x40, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x04, 0x12, 0x03, + 0x40, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, 0x03, 0x40, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x03, 0x40, 0x13, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x03, 0x40, 0x1b, 0x1f, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x08, 0x02, 0x04, 0x12, 0x03, 0x41, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x04, 0x04, 0x12, 0x03, 0x41, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, + 0x05, 0x12, 0x03, 0x41, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x41, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x03, 0x12, 0x03, 0x41, + 0x22, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, 0x12, 0x03, 0x42, 0x04, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x04, 0x12, 0x03, 0x42, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x05, 0x06, 0x12, 0x03, 0x42, 0x0d, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x05, 0x01, 0x12, 0x03, 0x42, 0x10, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x42, 0x15, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, + 0x03, 0x43, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x04, 0x12, 0x03, 0x43, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x05, 0x12, 0x03, 0x43, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x03, 0x43, 0x14, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x03, 0x43, 0x21, 0x25, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x07, 0x12, 0x03, 0x44, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x07, 0x04, 0x12, 0x03, 0x44, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x05, + 0x12, 0x03, 0x44, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x03, + 0x44, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x03, 0x44, 0x1d, + 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x08, 0x12, 0x03, 0x45, 0x04, 0x35, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x04, 0x12, 0x03, 0x45, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x08, 0x05, 0x12, 0x03, 0x45, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x08, 0x01, 0x12, 0x03, 0x45, 0x14, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, + 0x03, 0x12, 0x03, 0x45, 0x30, 0x34, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x09, 0x12, 0x03, + 0x46, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x04, 0x12, 0x03, 0x46, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x05, 0x12, 0x03, 0x46, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x01, 0x12, 0x03, 0x46, 0x14, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x09, 0x03, 0x12, 0x03, 0x46, 0x20, 0x24, 0x0a, 0x0a, 0x0a, 0x02, 0x05, + 0x02, 0x12, 0x04, 0x49, 0x00, 0x54, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x02, 0x01, 0x12, 0x03, + 0x49, 0x05, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x00, 0x12, 0x03, 0x4a, 0x04, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x04, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x02, 0x02, 0x00, 0x02, 0x12, 0x03, 0x4a, 0x12, 0x15, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x4b, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x01, 0x02, + 0x12, 0x03, 0x4b, 0x0e, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x02, 0x12, 0x03, 0x4c, + 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x04, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x02, 0x12, 0x03, 0x4c, 0x11, 0x14, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4d, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4d, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x03, 0x02, 0x12, 0x03, 0x4d, 0x0e, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x4e, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, 0x4e, + 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x04, 0x02, 0x12, 0x03, 0x4e, 0x11, 0x14, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x03, 0x4f, 0x04, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x02, 0x02, 0x05, 0x01, 0x12, 0x03, 0x4f, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x02, 0x02, 0x05, 0x02, 0x12, 0x03, 0x4f, 0x0e, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x50, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x06, 0x01, 0x12, + 0x03, 0x50, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x06, 0x02, 0x12, 0x03, 0x50, + 0x0f, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x07, 0x12, 0x03, 0x51, 0x04, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x07, 0x01, 0x12, 0x03, 0x51, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x02, 0x02, 0x07, 0x02, 0x12, 0x03, 0x51, 0x0d, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x02, 0x02, 0x08, 0x12, 0x03, 0x52, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x08, + 0x01, 0x12, 0x03, 0x52, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x08, 0x02, 0x12, + 0x03, 0x52, 0x0f, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x09, 0x12, 0x03, 0x53, 0x04, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x09, 0x01, 0x12, 0x03, 0x53, 0x04, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x09, 0x02, 0x12, 0x03, 0x53, 0x13, 0x16, 0x0a, 0x0a, 0x0a, + 0x02, 0x05, 0x03, 0x12, 0x04, 0x56, 0x00, 0x5b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x03, 0x01, + 0x12, 0x03, 0x56, 0x05, 0x0a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x03, 0x02, 0x00, 0x12, 0x03, 0x57, + 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x57, 0x04, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x00, 0x02, 0x12, 0x03, 0x57, 0x16, 0x19, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x03, 0x02, 0x01, 0x12, 0x03, 0x58, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x58, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, + 0x01, 0x02, 0x12, 0x03, 0x58, 0x10, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x03, 0x02, 0x02, 0x12, + 0x03, 0x59, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x59, + 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x02, 0x02, 0x12, 0x03, 0x59, 0x10, 0x13, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x03, 0x02, 0x03, 0x12, 0x03, 0x5a, 0x04, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5a, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x03, 0x02, 0x03, 0x02, 0x12, 0x03, 0x5a, 0x12, 0x15, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x04, 0x12, + 0x04, 0x5d, 0x00, 0x75, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x04, 0x01, 0x12, 0x03, 0x5d, 0x05, + 0x07, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x00, 0x12, 0x03, 0x5e, 0x04, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x5e, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x04, 0x02, 0x00, 0x02, 0x12, 0x03, 0x5e, 0x11, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x5f, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x5f, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x01, 0x02, 0x12, 0x03, + 0x5f, 0x11, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x02, 0x12, 0x03, 0x60, 0x04, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x60, 0x04, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x60, 0x0d, 0x10, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x04, 0x02, 0x03, 0x12, 0x03, 0x61, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x61, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x03, 0x02, + 0x12, 0x03, 0x61, 0x10, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x04, 0x12, 0x03, 0x62, + 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, 0x62, 0x04, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x04, 0x02, 0x12, 0x03, 0x62, 0x0d, 0x10, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x04, 0x02, 0x05, 0x12, 0x03, 0x63, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x04, 0x02, 0x05, 0x01, 0x12, 0x03, 0x63, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, + 0x05, 0x02, 0x12, 0x03, 0x63, 0x0f, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x06, 0x12, + 0x03, 0x64, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x06, 0x01, 0x12, 0x03, 0x64, + 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x06, 0x02, 0x12, 0x03, 0x64, 0x14, 0x17, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x07, 0x12, 0x03, 0x65, 0x04, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x04, 0x02, 0x07, 0x01, 0x12, 0x03, 0x65, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x04, 0x02, 0x07, 0x02, 0x12, 0x03, 0x65, 0x11, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, + 0x08, 0x12, 0x03, 0x66, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x08, 0x01, 0x12, + 0x03, 0x66, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x08, 0x02, 0x12, 0x03, 0x66, + 0x0e, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x09, 0x12, 0x03, 0x67, 0x04, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x09, 0x01, 0x12, 0x03, 0x67, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x04, 0x02, 0x09, 0x02, 0x12, 0x03, 0x67, 0x11, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x04, 0x02, 0x0a, 0x12, 0x03, 0x68, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0a, + 0x01, 0x12, 0x03, 0x68, 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0a, 0x02, 0x12, + 0x03, 0x68, 0x14, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x0b, 0x12, 0x03, 0x69, 0x04, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x69, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0b, 0x02, 0x12, 0x03, 0x69, 0x0f, 0x12, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x04, 0x02, 0x0c, 0x12, 0x03, 0x6a, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, + 0x02, 0x0c, 0x01, 0x12, 0x03, 0x6a, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0c, + 0x02, 0x12, 0x03, 0x6a, 0x12, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x0d, 0x12, 0x03, + 0x6b, 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x6b, 0x04, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0d, 0x02, 0x12, 0x03, 0x6b, 0x0d, 0x10, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x0e, 0x12, 0x03, 0x6c, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x04, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x6c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, + 0x02, 0x0e, 0x02, 0x12, 0x03, 0x6c, 0x0f, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x0f, + 0x12, 0x03, 0x6d, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0f, 0x01, 0x12, 0x03, + 0x6d, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x0f, 0x02, 0x12, 0x03, 0x6d, 0x11, + 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x10, 0x12, 0x03, 0x6e, 0x04, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x04, 0x02, 0x10, 0x01, 0x12, 0x03, 0x6e, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x04, 0x02, 0x10, 0x02, 0x12, 0x03, 0x6e, 0x0c, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, + 0x02, 0x11, 0x12, 0x03, 0x6f, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x11, 0x01, + 0x12, 0x03, 0x6f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x11, 0x02, 0x12, 0x03, + 0x6f, 0x0f, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x12, 0x12, 0x03, 0x70, 0x04, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x12, 0x01, 0x12, 0x03, 0x70, 0x04, 0x0b, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x04, 0x02, 0x12, 0x02, 0x12, 0x03, 0x70, 0x0e, 0x12, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x04, 0x02, 0x13, 0x12, 0x03, 0x71, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, + 0x13, 0x01, 0x12, 0x03, 0x71, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x13, 0x02, + 0x12, 0x03, 0x71, 0x0e, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x14, 0x12, 0x03, 0x72, + 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x14, 0x01, 0x12, 0x03, 0x72, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x14, 0x02, 0x12, 0x03, 0x72, 0x0f, 0x13, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x04, 0x02, 0x15, 0x12, 0x03, 0x73, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x04, 0x02, 0x15, 0x01, 0x12, 0x03, 0x73, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, + 0x15, 0x02, 0x12, 0x03, 0x73, 0x10, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x16, 0x12, + 0x03, 0x74, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x16, 0x01, 0x12, 0x03, 0x74, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x16, 0x02, 0x12, 0x03, 0x74, 0x0d, 0x11, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, 0x77, 0x00, 0x7d, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x09, 0x01, 0x12, 0x03, 0x77, 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, + 0x12, 0x03, 0x78, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x78, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x03, 0x78, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x78, 0x14, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x78, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x79, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x79, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x79, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x79, 0x13, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x79, + 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x03, 0x7a, 0x04, 0x23, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x04, 0x12, 0x03, 0x7a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x02, 0x05, 0x12, 0x03, 0x7a, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x02, 0x01, 0x12, 0x03, 0x7a, 0x13, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x7a, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x03, 0x12, + 0x03, 0x7b, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x04, 0x12, 0x03, 0x7b, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x05, 0x12, 0x03, 0x7b, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x01, 0x12, 0x03, 0x7b, 0x14, 0x1d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x03, 0x12, 0x03, 0x7b, 0x20, 0x23, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x09, 0x02, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x04, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x05, + 0x12, 0x03, 0x7c, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x7c, 0x13, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x03, 0x12, 0x03, 0x7c, 0x23, + 0x26, 0x0a, 0x0b, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x05, 0x7f, 0x00, 0x83, 0x01, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x7f, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x00, 0x12, 0x04, 0x80, 0x01, 0x04, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, + 0x04, 0x12, 0x04, 0x80, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, + 0x12, 0x04, 0x80, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, + 0x04, 0x80, 0x01, 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, + 0x80, 0x01, 0x1c, 0x1f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0x81, 0x01, + 0x04, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x04, 0x81, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x06, 0x12, 0x04, 0x81, 0x01, 0x0d, 0x1f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0x81, 0x01, 0x20, 0x22, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0x81, 0x01, 0x25, 0x28, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0x82, 0x01, 0x04, 0x23, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x02, 0x04, 0x12, 0x04, 0x82, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x01, 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x02, 0x03, 0x12, 0x04, 0x82, 0x01, 0x1f, 0x22, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, + 0x85, 0x01, 0x00, 0x87, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0x85, + 0x01, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x04, + 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, 0x04, 0x86, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, 0x86, 0x01, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0x86, 0x01, 0x14, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0x86, 0x01, 0x21, 0x24, 0x0a, 0x0c, 0x0a, + 0x02, 0x04, 0x0c, 0x12, 0x06, 0x89, 0x01, 0x00, 0x92, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0c, 0x01, 0x12, 0x04, 0x89, 0x01, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, + 0x12, 0x04, 0x8a, 0x01, 0x04, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, 0x12, + 0x04, 0x8a, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, 0x04, + 0x8a, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8a, + 0x01, 0x14, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8a, 0x01, + 0x29, 0x2c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, 0x8b, 0x01, 0x04, 0x37, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8b, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x06, 0x12, 0x04, 0x8b, 0x01, 0x0d, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8b, 0x01, 0x19, 0x2f, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8b, 0x01, 0x32, 0x36, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x02, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x3b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x02, 0x04, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x02, 0x06, 0x12, 0x04, 0x8c, 0x01, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, + 0x01, 0x12, 0x04, 0x8c, 0x01, 0x19, 0x33, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x03, + 0x12, 0x04, 0x8c, 0x01, 0x36, 0x3a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x03, 0x12, 0x04, + 0x8d, 0x01, 0x04, 0x46, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x04, 0x12, 0x04, 0x8d, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x06, 0x12, 0x04, 0x8d, 0x01, + 0x0d, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x20, + 0x3e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8d, 0x01, 0x41, 0x45, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x04, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x34, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x04, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x04, 0x05, 0x12, 0x04, 0x8e, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x04, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x13, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x2f, 0x33, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, + 0x02, 0x05, 0x12, 0x04, 0x8f, 0x01, 0x04, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, + 0x04, 0x12, 0x04, 0x8f, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x05, + 0x12, 0x04, 0x8f, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x01, 0x12, + 0x04, 0x8f, 0x01, 0x13, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x03, 0x12, 0x04, + 0x8f, 0x01, 0x20, 0x24, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x06, 0x12, 0x04, 0x90, 0x01, + 0x04, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x04, 0x12, 0x04, 0x90, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x06, 0x12, 0x04, 0x90, 0x01, 0x0d, 0x18, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x01, 0x12, 0x04, 0x90, 0x01, 0x19, 0x25, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x03, 0x12, 0x04, 0x90, 0x01, 0x28, 0x2c, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x07, 0x12, 0x04, 0x91, 0x01, 0x04, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x07, 0x04, 0x12, 0x04, 0x91, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x07, 0x06, 0x12, 0x04, 0x91, 0x01, 0x0d, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x07, 0x01, 0x12, 0x04, 0x91, 0x01, 0x21, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x07, 0x03, 0x12, 0x04, 0x91, 0x01, 0x26, 0x2a, 0x0a, 0x0c, 0x0a, 0x02, 0x05, 0x05, 0x12, 0x06, + 0x94, 0x01, 0x00, 0x97, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x05, 0x01, 0x12, 0x04, 0x94, + 0x01, 0x05, 0x10, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x05, 0x02, 0x00, 0x12, 0x04, 0x95, 0x01, 0x04, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x05, 0x02, 0x00, 0x01, 0x12, 0x04, 0x95, 0x01, 0x04, 0x0b, + 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x05, 0x02, 0x00, 0x02, 0x12, 0x04, 0x95, 0x01, 0x0e, 0x11, 0x0a, + 0x0c, 0x0a, 0x04, 0x05, 0x05, 0x02, 0x01, 0x12, 0x04, 0x96, 0x01, 0x04, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x05, 0x05, 0x02, 0x01, 0x01, 0x12, 0x04, 0x96, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x05, 0x02, 0x01, 0x02, 0x12, 0x04, 0x96, 0x01, 0x0f, 0x12, 0x0a, 0x0c, 0x0a, 0x02, 0x04, + 0x0d, 0x12, 0x06, 0x99, 0x01, 0x00, 0x9c, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, + 0x12, 0x04, 0x99, 0x01, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, + 0x9a, 0x01, 0x04, 0x2e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0x9a, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9a, 0x01, + 0x0d, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x20, + 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9a, 0x01, 0x2a, 0x2d, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x04, 0x30, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x04, 0x12, 0x04, 0x9b, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0d, 0x02, 0x01, 0x06, 0x12, 0x04, 0x9b, 0x01, 0x0d, 0x20, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x21, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0x9b, 0x01, 0x2c, 0x2f, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0e, + 0x12, 0x06, 0x9e, 0x01, 0x00, 0x9f, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, + 0x04, 0x9e, 0x01, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, 0xa1, 0x01, 0x00, + 0xa4, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0xa1, 0x01, 0x08, 0x1b, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x27, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x04, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x00, 0x05, 0x12, 0x04, 0xa2, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa2, 0x01, 0x14, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa2, 0x01, 0x23, 0x26, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x04, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, + 0x04, 0x12, 0x04, 0xa3, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x05, + 0x12, 0x04, 0xa3, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xa3, 0x01, 0x14, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xa3, 0x01, 0x21, 0x24, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/protocol/src/keyexchange.rs b/protocol/src/keyexchange.rs new file mode 100644 index 00000000..c64dd326 --- /dev/null +++ b/protocol/src/keyexchange.rs @@ -0,0 +1,7625 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct ClientHello { + // message fields + build_info: ::protobuf::SingularPtrField, + fingerprints_supported: ::std::vec::Vec, + cryptosuites_supported: ::std::vec::Vec, + powschemes_supported: ::std::vec::Vec, + login_crypto_hello: ::protobuf::SingularPtrField, + client_nonce: ::protobuf::SingularField<::std::vec::Vec>, + padding: ::protobuf::SingularField<::std::vec::Vec>, + feature_set: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ClientHello {} + +impl ClientHello { + pub fn new() -> ClientHello { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ClientHello { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ClientHello, + }; + unsafe { + instance.get(|| { + ClientHello { + build_info: ::protobuf::SingularPtrField::none(), + fingerprints_supported: ::std::vec::Vec::new(), + cryptosuites_supported: ::std::vec::Vec::new(), + powschemes_supported: ::std::vec::Vec::new(), + login_crypto_hello: ::protobuf::SingularPtrField::none(), + client_nonce: ::protobuf::SingularField::none(), + padding: ::protobuf::SingularField::none(), + feature_set: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .BuildInfo build_info = 10; + + pub fn clear_build_info(&mut self) { + self.build_info.clear(); + } + + pub fn has_build_info(&self) -> bool { + self.build_info.is_some() + } + + // Param is passed by value, moved + pub fn set_build_info(&mut self, v: BuildInfo) { + self.build_info = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_build_info(&mut self) -> &mut BuildInfo { + if self.build_info.is_none() { + self.build_info.set_default(); + }; + self.build_info.as_mut().unwrap() + } + + // Take field + pub fn take_build_info(&mut self) -> BuildInfo { + self.build_info.take().unwrap_or_else(|| BuildInfo::new()) + } + + pub fn get_build_info(&self) -> &BuildInfo { + self.build_info.as_ref().unwrap_or_else(|| BuildInfo::default_instance()) + } + + // repeated .Fingerprint fingerprints_supported = 20; + + pub fn clear_fingerprints_supported(&mut self) { + self.fingerprints_supported.clear(); + } + + // Param is passed by value, moved + pub fn set_fingerprints_supported(&mut self, v: ::std::vec::Vec) { + self.fingerprints_supported = v; + } + + // Mutable pointer to the field. + pub fn mut_fingerprints_supported(&mut self) -> &mut ::std::vec::Vec { + &mut self.fingerprints_supported + } + + // Take field + pub fn take_fingerprints_supported(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.fingerprints_supported, ::std::vec::Vec::new()) + } + + pub fn get_fingerprints_supported(&self) -> &[Fingerprint] { + &self.fingerprints_supported + } + + // repeated .Cryptosuite cryptosuites_supported = 30; + + pub fn clear_cryptosuites_supported(&mut self) { + self.cryptosuites_supported.clear(); + } + + // Param is passed by value, moved + pub fn set_cryptosuites_supported(&mut self, v: ::std::vec::Vec) { + self.cryptosuites_supported = v; + } + + // Mutable pointer to the field. + pub fn mut_cryptosuites_supported(&mut self) -> &mut ::std::vec::Vec { + &mut self.cryptosuites_supported + } + + // Take field + pub fn take_cryptosuites_supported(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.cryptosuites_supported, ::std::vec::Vec::new()) + } + + pub fn get_cryptosuites_supported(&self) -> &[Cryptosuite] { + &self.cryptosuites_supported + } + + // repeated .Powscheme powschemes_supported = 40; + + pub fn clear_powschemes_supported(&mut self) { + self.powschemes_supported.clear(); + } + + // Param is passed by value, moved + pub fn set_powschemes_supported(&mut self, v: ::std::vec::Vec) { + self.powschemes_supported = v; + } + + // Mutable pointer to the field. + pub fn mut_powschemes_supported(&mut self) -> &mut ::std::vec::Vec { + &mut self.powschemes_supported + } + + // Take field + pub fn take_powschemes_supported(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.powschemes_supported, ::std::vec::Vec::new()) + } + + pub fn get_powschemes_supported(&self) -> &[Powscheme] { + &self.powschemes_supported + } + + // required .LoginCryptoHelloUnion login_crypto_hello = 50; + + pub fn clear_login_crypto_hello(&mut self) { + self.login_crypto_hello.clear(); + } + + pub fn has_login_crypto_hello(&self) -> bool { + self.login_crypto_hello.is_some() + } + + // Param is passed by value, moved + pub fn set_login_crypto_hello(&mut self, v: LoginCryptoHelloUnion) { + self.login_crypto_hello = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_login_crypto_hello(&mut self) -> &mut LoginCryptoHelloUnion { + if self.login_crypto_hello.is_none() { + self.login_crypto_hello.set_default(); + }; + self.login_crypto_hello.as_mut().unwrap() + } + + // Take field + pub fn take_login_crypto_hello(&mut self) -> LoginCryptoHelloUnion { + self.login_crypto_hello.take().unwrap_or_else(|| LoginCryptoHelloUnion::new()) + } + + pub fn get_login_crypto_hello(&self) -> &LoginCryptoHelloUnion { + self.login_crypto_hello.as_ref().unwrap_or_else(|| LoginCryptoHelloUnion::default_instance()) + } + + // required bytes client_nonce = 60; + + pub fn clear_client_nonce(&mut self) { + self.client_nonce.clear(); + } + + pub fn has_client_nonce(&self) -> bool { + self.client_nonce.is_some() + } + + // Param is passed by value, moved + pub fn set_client_nonce(&mut self, v: ::std::vec::Vec) { + self.client_nonce = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_client_nonce(&mut self) -> &mut ::std::vec::Vec { + if self.client_nonce.is_none() { + self.client_nonce.set_default(); + }; + self.client_nonce.as_mut().unwrap() + } + + // Take field + pub fn take_client_nonce(&mut self) -> ::std::vec::Vec { + self.client_nonce.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_client_nonce(&self) -> &[u8] { + match self.client_nonce.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional bytes padding = 70; + + pub fn clear_padding(&mut self) { + self.padding.clear(); + } + + pub fn has_padding(&self) -> bool { + self.padding.is_some() + } + + // Param is passed by value, moved + pub fn set_padding(&mut self, v: ::std::vec::Vec) { + self.padding = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_padding(&mut self) -> &mut ::std::vec::Vec { + if self.padding.is_none() { + self.padding.set_default(); + }; + self.padding.as_mut().unwrap() + } + + // Take field + pub fn take_padding(&mut self) -> ::std::vec::Vec { + self.padding.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_padding(&self) -> &[u8] { + match self.padding.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional .FeatureSet feature_set = 80; + + pub fn clear_feature_set(&mut self) { + self.feature_set.clear(); + } + + pub fn has_feature_set(&self) -> bool { + self.feature_set.is_some() + } + + // Param is passed by value, moved + pub fn set_feature_set(&mut self, v: FeatureSet) { + self.feature_set = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_feature_set(&mut self) -> &mut FeatureSet { + if self.feature_set.is_none() { + self.feature_set.set_default(); + }; + self.feature_set.as_mut().unwrap() + } + + // Take field + pub fn take_feature_set(&mut self) -> FeatureSet { + self.feature_set.take().unwrap_or_else(|| FeatureSet::new()) + } + + pub fn get_feature_set(&self) -> &FeatureSet { + self.feature_set.as_ref().unwrap_or_else(|| FeatureSet::default_instance()) + } +} + +impl ::protobuf::Message for ClientHello { + fn is_initialized(&self) -> bool { + if self.build_info.is_none() { + return false; + }; + if self.login_crypto_hello.is_none() { + return false; + }; + if self.client_nonce.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.build_info)); + }, + 20 => { + try!(::protobuf::rt::read_repeated_enum_into(wire_type, is, &mut self.fingerprints_supported)); + }, + 30 => { + try!(::protobuf::rt::read_repeated_enum_into(wire_type, is, &mut self.cryptosuites_supported)); + }, + 40 => { + try!(::protobuf::rt::read_repeated_enum_into(wire_type, is, &mut self.powschemes_supported)); + }, + 50 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_crypto_hello)); + }, + 60 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.client_nonce)); + }, + 70 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.padding)); + }, + 80 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.feature_set)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.build_info { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.fingerprints_supported { + my_size += ::protobuf::rt::enum_size(20, *value); + }; + for value in &self.cryptosuites_supported { + my_size += ::protobuf::rt::enum_size(30, *value); + }; + for value in &self.powschemes_supported { + my_size += ::protobuf::rt::enum_size(40, *value); + }; + for value in &self.login_crypto_hello { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.client_nonce { + my_size += ::protobuf::rt::bytes_size(60, &value); + }; + for value in &self.padding { + my_size += ::protobuf::rt::bytes_size(70, &value); + }; + for value in &self.feature_set { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.build_info.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.fingerprints_supported { + try!(os.write_enum(20, v.value())); + }; + for v in &self.cryptosuites_supported { + try!(os.write_enum(30, v.value())); + }; + for v in &self.powschemes_supported { + try!(os.write_enum(40, v.value())); + }; + if let Some(v) = self.login_crypto_hello.as_ref() { + try!(os.write_tag(50, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.client_nonce.as_ref() { + try!(os.write_bytes(60, &v)); + }; + if let Some(v) = self.padding.as_ref() { + try!(os.write_bytes(70, &v)); + }; + if let Some(v) = self.feature_set.as_ref() { + try!(os.write_tag(80, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ClientHello { + fn new() -> ClientHello { + ClientHello::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "build_info", + ClientHello::has_build_info, + ClientHello::get_build_info, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_enum_accessor( + "fingerprints_supported", + ClientHello::get_fingerprints_supported, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_enum_accessor( + "cryptosuites_supported", + ClientHello::get_cryptosuites_supported, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_enum_accessor( + "powschemes_supported", + ClientHello::get_powschemes_supported, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "login_crypto_hello", + ClientHello::has_login_crypto_hello, + ClientHello::get_login_crypto_hello, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "client_nonce", + ClientHello::has_client_nonce, + ClientHello::get_client_nonce, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "padding", + ClientHello::has_padding, + ClientHello::get_padding, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "feature_set", + ClientHello::has_feature_set, + ClientHello::get_feature_set, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ClientHello", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ClientHello { + fn clear(&mut self) { + self.clear_build_info(); + self.clear_fingerprints_supported(); + self.clear_cryptosuites_supported(); + self.clear_powschemes_supported(); + self.clear_login_crypto_hello(); + self.clear_client_nonce(); + self.clear_padding(); + self.clear_feature_set(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ClientHello { + fn eq(&self, other: &ClientHello) -> bool { + self.build_info == other.build_info && + self.fingerprints_supported == other.fingerprints_supported && + self.cryptosuites_supported == other.cryptosuites_supported && + self.powschemes_supported == other.powschemes_supported && + self.login_crypto_hello == other.login_crypto_hello && + self.client_nonce == other.client_nonce && + self.padding == other.padding && + self.feature_set == other.feature_set && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ClientHello { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct BuildInfo { + // message fields + product: ::std::option::Option, + product_flags: ::std::vec::Vec, + platform: ::std::option::Option, + version: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for BuildInfo {} + +impl BuildInfo { + pub fn new() -> BuildInfo { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static BuildInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BuildInfo, + }; + unsafe { + instance.get(|| { + BuildInfo { + product: ::std::option::Option::None, + product_flags: ::std::vec::Vec::new(), + platform: ::std::option::Option::None, + version: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .Product product = 10; + + pub fn clear_product(&mut self) { + self.product = ::std::option::Option::None; + } + + pub fn has_product(&self) -> bool { + self.product.is_some() + } + + // Param is passed by value, moved + pub fn set_product(&mut self, v: Product) { + self.product = ::std::option::Option::Some(v); + } + + pub fn get_product(&self) -> Product { + self.product.unwrap_or(Product::PRODUCT_CLIENT) + } + + // repeated .ProductFlags product_flags = 20; + + pub fn clear_product_flags(&mut self) { + self.product_flags.clear(); + } + + // Param is passed by value, moved + pub fn set_product_flags(&mut self, v: ::std::vec::Vec) { + self.product_flags = v; + } + + // Mutable pointer to the field. + pub fn mut_product_flags(&mut self) -> &mut ::std::vec::Vec { + &mut self.product_flags + } + + // Take field + pub fn take_product_flags(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.product_flags, ::std::vec::Vec::new()) + } + + pub fn get_product_flags(&self) -> &[ProductFlags] { + &self.product_flags + } + + // required .Platform platform = 30; + + pub fn clear_platform(&mut self) { + self.platform = ::std::option::Option::None; + } + + pub fn has_platform(&self) -> bool { + self.platform.is_some() + } + + // Param is passed by value, moved + pub fn set_platform(&mut self, v: Platform) { + self.platform = ::std::option::Option::Some(v); + } + + pub fn get_platform(&self) -> Platform { + self.platform.unwrap_or(Platform::PLATFORM_WIN32_X86) + } + + // required uint64 version = 40; + + pub fn clear_version(&mut self) { + self.version = ::std::option::Option::None; + } + + pub fn has_version(&self) -> bool { + self.version.is_some() + } + + // Param is passed by value, moved + pub fn set_version(&mut self, v: u64) { + self.version = ::std::option::Option::Some(v); + } + + pub fn get_version(&self) -> u64 { + self.version.unwrap_or(0) + } +} + +impl ::protobuf::Message for BuildInfo { + fn is_initialized(&self) -> bool { + if self.product.is_none() { + return false; + }; + if self.platform.is_none() { + return false; + }; + if self.version.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.product = ::std::option::Option::Some(tmp); + }, + 20 => { + try!(::protobuf::rt::read_repeated_enum_into(wire_type, is, &mut self.product_flags)); + }, + 30 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.platform = ::std::option::Option::Some(tmp); + }, + 40 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint64()); + self.version = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.product { + my_size += ::protobuf::rt::enum_size(10, *value); + }; + for value in &self.product_flags { + my_size += ::protobuf::rt::enum_size(20, *value); + }; + for value in &self.platform { + my_size += ::protobuf::rt::enum_size(30, *value); + }; + for value in &self.version { + my_size += ::protobuf::rt::value_size(40, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.product { + try!(os.write_enum(10, v.value())); + }; + for v in &self.product_flags { + try!(os.write_enum(20, v.value())); + }; + if let Some(v) = self.platform { + try!(os.write_enum(30, v.value())); + }; + if let Some(v) = self.version { + try!(os.write_uint64(40, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for BuildInfo { + fn new() -> BuildInfo { + BuildInfo::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "product", + BuildInfo::has_product, + BuildInfo::get_product, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_enum_accessor( + "product_flags", + BuildInfo::get_product_flags, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "platform", + BuildInfo::has_platform, + BuildInfo::get_platform, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u64_accessor( + "version", + BuildInfo::has_version, + BuildInfo::get_version, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BuildInfo", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for BuildInfo { + fn clear(&mut self) { + self.clear_product(); + self.clear_product_flags(); + self.clear_platform(); + self.clear_version(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for BuildInfo { + fn eq(&self, other: &BuildInfo) -> bool { + self.product == other.product && + self.product_flags == other.product_flags && + self.platform == other.platform && + self.version == other.version && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for BuildInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoHelloUnion { + // message fields + diffie_hellman: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoHelloUnion {} + +impl LoginCryptoHelloUnion { + pub fn new() -> LoginCryptoHelloUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoHelloUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoHelloUnion, + }; + unsafe { + instance.get(|| { + LoginCryptoHelloUnion { + diffie_hellman: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .LoginCryptoDiffieHellmanHello diffie_hellman = 10; + + pub fn clear_diffie_hellman(&mut self) { + self.diffie_hellman.clear(); + } + + pub fn has_diffie_hellman(&self) -> bool { + self.diffie_hellman.is_some() + } + + // Param is passed by value, moved + pub fn set_diffie_hellman(&mut self, v: LoginCryptoDiffieHellmanHello) { + self.diffie_hellman = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_diffie_hellman(&mut self) -> &mut LoginCryptoDiffieHellmanHello { + if self.diffie_hellman.is_none() { + self.diffie_hellman.set_default(); + }; + self.diffie_hellman.as_mut().unwrap() + } + + // Take field + pub fn take_diffie_hellman(&mut self) -> LoginCryptoDiffieHellmanHello { + self.diffie_hellman.take().unwrap_or_else(|| LoginCryptoDiffieHellmanHello::new()) + } + + pub fn get_diffie_hellman(&self) -> &LoginCryptoDiffieHellmanHello { + self.diffie_hellman.as_ref().unwrap_or_else(|| LoginCryptoDiffieHellmanHello::default_instance()) + } +} + +impl ::protobuf::Message for LoginCryptoHelloUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.diffie_hellman)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.diffie_hellman { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.diffie_hellman.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoHelloUnion { + fn new() -> LoginCryptoHelloUnion { + LoginCryptoHelloUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "diffie_hellman", + LoginCryptoHelloUnion::has_diffie_hellman, + LoginCryptoHelloUnion::get_diffie_hellman, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoHelloUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoHelloUnion { + fn clear(&mut self) { + self.clear_diffie_hellman(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoHelloUnion { + fn eq(&self, other: &LoginCryptoHelloUnion) -> bool { + self.diffie_hellman == other.diffie_hellman && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoHelloUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoDiffieHellmanHello { + // message fields + gc: ::protobuf::SingularField<::std::vec::Vec>, + server_keys_known: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoDiffieHellmanHello {} + +impl LoginCryptoDiffieHellmanHello { + pub fn new() -> LoginCryptoDiffieHellmanHello { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoDiffieHellmanHello { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoDiffieHellmanHello, + }; + unsafe { + instance.get(|| { + LoginCryptoDiffieHellmanHello { + gc: ::protobuf::SingularField::none(), + server_keys_known: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes gc = 10; + + pub fn clear_gc(&mut self) { + self.gc.clear(); + } + + pub fn has_gc(&self) -> bool { + self.gc.is_some() + } + + // Param is passed by value, moved + pub fn set_gc(&mut self, v: ::std::vec::Vec) { + self.gc = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gc(&mut self) -> &mut ::std::vec::Vec { + if self.gc.is_none() { + self.gc.set_default(); + }; + self.gc.as_mut().unwrap() + } + + // Take field + pub fn take_gc(&mut self) -> ::std::vec::Vec { + self.gc.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gc(&self) -> &[u8] { + match self.gc.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required uint32 server_keys_known = 20; + + pub fn clear_server_keys_known(&mut self) { + self.server_keys_known = ::std::option::Option::None; + } + + pub fn has_server_keys_known(&self) -> bool { + self.server_keys_known.is_some() + } + + // Param is passed by value, moved + pub fn set_server_keys_known(&mut self, v: u32) { + self.server_keys_known = ::std::option::Option::Some(v); + } + + pub fn get_server_keys_known(&self) -> u32 { + self.server_keys_known.unwrap_or(0) + } +} + +impl ::protobuf::Message for LoginCryptoDiffieHellmanHello { + fn is_initialized(&self) -> bool { + if self.gc.is_none() { + return false; + }; + if self.server_keys_known.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gc)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.server_keys_known = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gc { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + for value in &self.server_keys_known { + my_size += ::protobuf::rt::value_size(20, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gc.as_ref() { + try!(os.write_bytes(10, &v)); + }; + if let Some(v) = self.server_keys_known { + try!(os.write_uint32(20, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoDiffieHellmanHello { + fn new() -> LoginCryptoDiffieHellmanHello { + LoginCryptoDiffieHellmanHello::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gc", + LoginCryptoDiffieHellmanHello::has_gc, + LoginCryptoDiffieHellmanHello::get_gc, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "server_keys_known", + LoginCryptoDiffieHellmanHello::has_server_keys_known, + LoginCryptoDiffieHellmanHello::get_server_keys_known, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoDiffieHellmanHello", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoDiffieHellmanHello { + fn clear(&mut self) { + self.clear_gc(); + self.clear_server_keys_known(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoDiffieHellmanHello { + fn eq(&self, other: &LoginCryptoDiffieHellmanHello) -> bool { + self.gc == other.gc && + self.server_keys_known == other.server_keys_known && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoDiffieHellmanHello { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FeatureSet { + // message fields + autoupdate2: ::std::option::Option, + current_location: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FeatureSet {} + +impl FeatureSet { + pub fn new() -> FeatureSet { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FeatureSet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FeatureSet, + }; + unsafe { + instance.get(|| { + FeatureSet { + autoupdate2: ::std::option::Option::None, + current_location: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bool autoupdate2 = 1; + + pub fn clear_autoupdate2(&mut self) { + self.autoupdate2 = ::std::option::Option::None; + } + + pub fn has_autoupdate2(&self) -> bool { + self.autoupdate2.is_some() + } + + // Param is passed by value, moved + pub fn set_autoupdate2(&mut self, v: bool) { + self.autoupdate2 = ::std::option::Option::Some(v); + } + + pub fn get_autoupdate2(&self) -> bool { + self.autoupdate2.unwrap_or(false) + } + + // optional bool current_location = 2; + + pub fn clear_current_location(&mut self) { + self.current_location = ::std::option::Option::None; + } + + pub fn has_current_location(&self) -> bool { + self.current_location.is_some() + } + + // Param is passed by value, moved + pub fn set_current_location(&mut self, v: bool) { + self.current_location = ::std::option::Option::Some(v); + } + + pub fn get_current_location(&self) -> bool { + self.current_location.unwrap_or(false) + } +} + +impl ::protobuf::Message for FeatureSet { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.autoupdate2 = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.current_location = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.autoupdate2.is_some() { + my_size += 2; + }; + if self.current_location.is_some() { + my_size += 2; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.autoupdate2 { + try!(os.write_bool(1, v)); + }; + if let Some(v) = self.current_location { + try!(os.write_bool(2, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FeatureSet { + fn new() -> FeatureSet { + FeatureSet::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "autoupdate2", + FeatureSet::has_autoupdate2, + FeatureSet::get_autoupdate2, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "current_location", + FeatureSet::has_current_location, + FeatureSet::get_current_location, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FeatureSet", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FeatureSet { + fn clear(&mut self) { + self.clear_autoupdate2(); + self.clear_current_location(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FeatureSet { + fn eq(&self, other: &FeatureSet) -> bool { + self.autoupdate2 == other.autoupdate2 && + self.current_location == other.current_location && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FeatureSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct APResponseMessage { + // message fields + challenge: ::protobuf::SingularPtrField, + upgrade: ::protobuf::SingularPtrField, + login_failed: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for APResponseMessage {} + +impl APResponseMessage { + pub fn new() -> APResponseMessage { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static APResponseMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const APResponseMessage, + }; + unsafe { + instance.get(|| { + APResponseMessage { + challenge: ::protobuf::SingularPtrField::none(), + upgrade: ::protobuf::SingularPtrField::none(), + login_failed: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .APChallenge challenge = 10; + + pub fn clear_challenge(&mut self) { + self.challenge.clear(); + } + + pub fn has_challenge(&self) -> bool { + self.challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_challenge(&mut self, v: APChallenge) { + self.challenge = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_challenge(&mut self) -> &mut APChallenge { + if self.challenge.is_none() { + self.challenge.set_default(); + }; + self.challenge.as_mut().unwrap() + } + + // Take field + pub fn take_challenge(&mut self) -> APChallenge { + self.challenge.take().unwrap_or_else(|| APChallenge::new()) + } + + pub fn get_challenge(&self) -> &APChallenge { + self.challenge.as_ref().unwrap_or_else(|| APChallenge::default_instance()) + } + + // optional .UpgradeRequiredMessage upgrade = 20; + + pub fn clear_upgrade(&mut self) { + self.upgrade.clear(); + } + + pub fn has_upgrade(&self) -> bool { + self.upgrade.is_some() + } + + // Param is passed by value, moved + pub fn set_upgrade(&mut self, v: UpgradeRequiredMessage) { + self.upgrade = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_upgrade(&mut self) -> &mut UpgradeRequiredMessage { + if self.upgrade.is_none() { + self.upgrade.set_default(); + }; + self.upgrade.as_mut().unwrap() + } + + // Take field + pub fn take_upgrade(&mut self) -> UpgradeRequiredMessage { + self.upgrade.take().unwrap_or_else(|| UpgradeRequiredMessage::new()) + } + + pub fn get_upgrade(&self) -> &UpgradeRequiredMessage { + self.upgrade.as_ref().unwrap_or_else(|| UpgradeRequiredMessage::default_instance()) + } + + // optional .APLoginFailed login_failed = 30; + + pub fn clear_login_failed(&mut self) { + self.login_failed.clear(); + } + + pub fn has_login_failed(&self) -> bool { + self.login_failed.is_some() + } + + // Param is passed by value, moved + pub fn set_login_failed(&mut self, v: APLoginFailed) { + self.login_failed = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_login_failed(&mut self) -> &mut APLoginFailed { + if self.login_failed.is_none() { + self.login_failed.set_default(); + }; + self.login_failed.as_mut().unwrap() + } + + // Take field + pub fn take_login_failed(&mut self) -> APLoginFailed { + self.login_failed.take().unwrap_or_else(|| APLoginFailed::new()) + } + + pub fn get_login_failed(&self) -> &APLoginFailed { + self.login_failed.as_ref().unwrap_or_else(|| APLoginFailed::default_instance()) + } +} + +impl ::protobuf::Message for APResponseMessage { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.challenge)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.upgrade)); + }, + 30 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_failed)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.challenge { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.upgrade { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.login_failed { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.challenge.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.upgrade.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.login_failed.as_ref() { + try!(os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for APResponseMessage { + fn new() -> APResponseMessage { + APResponseMessage::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "challenge", + APResponseMessage::has_challenge, + APResponseMessage::get_challenge, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "upgrade", + APResponseMessage::has_upgrade, + APResponseMessage::get_upgrade, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "login_failed", + APResponseMessage::has_login_failed, + APResponseMessage::get_login_failed, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "APResponseMessage", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for APResponseMessage { + fn clear(&mut self) { + self.clear_challenge(); + self.clear_upgrade(); + self.clear_login_failed(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for APResponseMessage { + fn eq(&self, other: &APResponseMessage) -> bool { + self.challenge == other.challenge && + self.upgrade == other.upgrade && + self.login_failed == other.login_failed && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for APResponseMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct APChallenge { + // message fields + login_crypto_challenge: ::protobuf::SingularPtrField, + fingerprint_challenge: ::protobuf::SingularPtrField, + pow_challenge: ::protobuf::SingularPtrField, + crypto_challenge: ::protobuf::SingularPtrField, + server_nonce: ::protobuf::SingularField<::std::vec::Vec>, + padding: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for APChallenge {} + +impl APChallenge { + pub fn new() -> APChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static APChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const APChallenge, + }; + unsafe { + instance.get(|| { + APChallenge { + login_crypto_challenge: ::protobuf::SingularPtrField::none(), + fingerprint_challenge: ::protobuf::SingularPtrField::none(), + pow_challenge: ::protobuf::SingularPtrField::none(), + crypto_challenge: ::protobuf::SingularPtrField::none(), + server_nonce: ::protobuf::SingularField::none(), + padding: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .LoginCryptoChallengeUnion login_crypto_challenge = 10; + + pub fn clear_login_crypto_challenge(&mut self) { + self.login_crypto_challenge.clear(); + } + + pub fn has_login_crypto_challenge(&self) -> bool { + self.login_crypto_challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_login_crypto_challenge(&mut self, v: LoginCryptoChallengeUnion) { + self.login_crypto_challenge = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_login_crypto_challenge(&mut self) -> &mut LoginCryptoChallengeUnion { + if self.login_crypto_challenge.is_none() { + self.login_crypto_challenge.set_default(); + }; + self.login_crypto_challenge.as_mut().unwrap() + } + + // Take field + pub fn take_login_crypto_challenge(&mut self) -> LoginCryptoChallengeUnion { + self.login_crypto_challenge.take().unwrap_or_else(|| LoginCryptoChallengeUnion::new()) + } + + pub fn get_login_crypto_challenge(&self) -> &LoginCryptoChallengeUnion { + self.login_crypto_challenge.as_ref().unwrap_or_else(|| LoginCryptoChallengeUnion::default_instance()) + } + + // required .FingerprintChallengeUnion fingerprint_challenge = 20; + + pub fn clear_fingerprint_challenge(&mut self) { + self.fingerprint_challenge.clear(); + } + + pub fn has_fingerprint_challenge(&self) -> bool { + self.fingerprint_challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_fingerprint_challenge(&mut self, v: FingerprintChallengeUnion) { + self.fingerprint_challenge = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_fingerprint_challenge(&mut self) -> &mut FingerprintChallengeUnion { + if self.fingerprint_challenge.is_none() { + self.fingerprint_challenge.set_default(); + }; + self.fingerprint_challenge.as_mut().unwrap() + } + + // Take field + pub fn take_fingerprint_challenge(&mut self) -> FingerprintChallengeUnion { + self.fingerprint_challenge.take().unwrap_or_else(|| FingerprintChallengeUnion::new()) + } + + pub fn get_fingerprint_challenge(&self) -> &FingerprintChallengeUnion { + self.fingerprint_challenge.as_ref().unwrap_or_else(|| FingerprintChallengeUnion::default_instance()) + } + + // required .PoWChallengeUnion pow_challenge = 30; + + pub fn clear_pow_challenge(&mut self) { + self.pow_challenge.clear(); + } + + pub fn has_pow_challenge(&self) -> bool { + self.pow_challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_pow_challenge(&mut self, v: PoWChallengeUnion) { + self.pow_challenge = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_pow_challenge(&mut self) -> &mut PoWChallengeUnion { + if self.pow_challenge.is_none() { + self.pow_challenge.set_default(); + }; + self.pow_challenge.as_mut().unwrap() + } + + // Take field + pub fn take_pow_challenge(&mut self) -> PoWChallengeUnion { + self.pow_challenge.take().unwrap_or_else(|| PoWChallengeUnion::new()) + } + + pub fn get_pow_challenge(&self) -> &PoWChallengeUnion { + self.pow_challenge.as_ref().unwrap_or_else(|| PoWChallengeUnion::default_instance()) + } + + // required .CryptoChallengeUnion crypto_challenge = 40; + + pub fn clear_crypto_challenge(&mut self) { + self.crypto_challenge.clear(); + } + + pub fn has_crypto_challenge(&self) -> bool { + self.crypto_challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_crypto_challenge(&mut self, v: CryptoChallengeUnion) { + self.crypto_challenge = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_crypto_challenge(&mut self) -> &mut CryptoChallengeUnion { + if self.crypto_challenge.is_none() { + self.crypto_challenge.set_default(); + }; + self.crypto_challenge.as_mut().unwrap() + } + + // Take field + pub fn take_crypto_challenge(&mut self) -> CryptoChallengeUnion { + self.crypto_challenge.take().unwrap_or_else(|| CryptoChallengeUnion::new()) + } + + pub fn get_crypto_challenge(&self) -> &CryptoChallengeUnion { + self.crypto_challenge.as_ref().unwrap_or_else(|| CryptoChallengeUnion::default_instance()) + } + + // required bytes server_nonce = 50; + + pub fn clear_server_nonce(&mut self) { + self.server_nonce.clear(); + } + + pub fn has_server_nonce(&self) -> bool { + self.server_nonce.is_some() + } + + // Param is passed by value, moved + pub fn set_server_nonce(&mut self, v: ::std::vec::Vec) { + self.server_nonce = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_server_nonce(&mut self) -> &mut ::std::vec::Vec { + if self.server_nonce.is_none() { + self.server_nonce.set_default(); + }; + self.server_nonce.as_mut().unwrap() + } + + // Take field + pub fn take_server_nonce(&mut self) -> ::std::vec::Vec { + self.server_nonce.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_server_nonce(&self) -> &[u8] { + match self.server_nonce.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional bytes padding = 60; + + pub fn clear_padding(&mut self) { + self.padding.clear(); + } + + pub fn has_padding(&self) -> bool { + self.padding.is_some() + } + + // Param is passed by value, moved + pub fn set_padding(&mut self, v: ::std::vec::Vec) { + self.padding = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_padding(&mut self) -> &mut ::std::vec::Vec { + if self.padding.is_none() { + self.padding.set_default(); + }; + self.padding.as_mut().unwrap() + } + + // Take field + pub fn take_padding(&mut self) -> ::std::vec::Vec { + self.padding.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_padding(&self) -> &[u8] { + match self.padding.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for APChallenge { + fn is_initialized(&self) -> bool { + if self.login_crypto_challenge.is_none() { + return false; + }; + if self.fingerprint_challenge.is_none() { + return false; + }; + if self.pow_challenge.is_none() { + return false; + }; + if self.crypto_challenge.is_none() { + return false; + }; + if self.server_nonce.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_crypto_challenge)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fingerprint_challenge)); + }, + 30 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pow_challenge)); + }, + 40 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.crypto_challenge)); + }, + 50 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.server_nonce)); + }, + 60 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.padding)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.login_crypto_challenge { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.fingerprint_challenge { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.pow_challenge { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.crypto_challenge { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.server_nonce { + my_size += ::protobuf::rt::bytes_size(50, &value); + }; + for value in &self.padding { + my_size += ::protobuf::rt::bytes_size(60, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.login_crypto_challenge.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.fingerprint_challenge.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.pow_challenge.as_ref() { + try!(os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.crypto_challenge.as_ref() { + try!(os.write_tag(40, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.server_nonce.as_ref() { + try!(os.write_bytes(50, &v)); + }; + if let Some(v) = self.padding.as_ref() { + try!(os.write_bytes(60, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for APChallenge { + fn new() -> APChallenge { + APChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "login_crypto_challenge", + APChallenge::has_login_crypto_challenge, + APChallenge::get_login_crypto_challenge, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "fingerprint_challenge", + APChallenge::has_fingerprint_challenge, + APChallenge::get_fingerprint_challenge, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "pow_challenge", + APChallenge::has_pow_challenge, + APChallenge::get_pow_challenge, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "crypto_challenge", + APChallenge::has_crypto_challenge, + APChallenge::get_crypto_challenge, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "server_nonce", + APChallenge::has_server_nonce, + APChallenge::get_server_nonce, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "padding", + APChallenge::has_padding, + APChallenge::get_padding, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "APChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for APChallenge { + fn clear(&mut self) { + self.clear_login_crypto_challenge(); + self.clear_fingerprint_challenge(); + self.clear_pow_challenge(); + self.clear_crypto_challenge(); + self.clear_server_nonce(); + self.clear_padding(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for APChallenge { + fn eq(&self, other: &APChallenge) -> bool { + self.login_crypto_challenge == other.login_crypto_challenge && + self.fingerprint_challenge == other.fingerprint_challenge && + self.pow_challenge == other.pow_challenge && + self.crypto_challenge == other.crypto_challenge && + self.server_nonce == other.server_nonce && + self.padding == other.padding && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for APChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoChallengeUnion { + // message fields + diffie_hellman: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoChallengeUnion {} + +impl LoginCryptoChallengeUnion { + pub fn new() -> LoginCryptoChallengeUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoChallengeUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoChallengeUnion, + }; + unsafe { + instance.get(|| { + LoginCryptoChallengeUnion { + diffie_hellman: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .LoginCryptoDiffieHellmanChallenge diffie_hellman = 10; + + pub fn clear_diffie_hellman(&mut self) { + self.diffie_hellman.clear(); + } + + pub fn has_diffie_hellman(&self) -> bool { + self.diffie_hellman.is_some() + } + + // Param is passed by value, moved + pub fn set_diffie_hellman(&mut self, v: LoginCryptoDiffieHellmanChallenge) { + self.diffie_hellman = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_diffie_hellman(&mut self) -> &mut LoginCryptoDiffieHellmanChallenge { + if self.diffie_hellman.is_none() { + self.diffie_hellman.set_default(); + }; + self.diffie_hellman.as_mut().unwrap() + } + + // Take field + pub fn take_diffie_hellman(&mut self) -> LoginCryptoDiffieHellmanChallenge { + self.diffie_hellman.take().unwrap_or_else(|| LoginCryptoDiffieHellmanChallenge::new()) + } + + pub fn get_diffie_hellman(&self) -> &LoginCryptoDiffieHellmanChallenge { + self.diffie_hellman.as_ref().unwrap_or_else(|| LoginCryptoDiffieHellmanChallenge::default_instance()) + } +} + +impl ::protobuf::Message for LoginCryptoChallengeUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.diffie_hellman)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.diffie_hellman { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.diffie_hellman.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoChallengeUnion { + fn new() -> LoginCryptoChallengeUnion { + LoginCryptoChallengeUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "diffie_hellman", + LoginCryptoChallengeUnion::has_diffie_hellman, + LoginCryptoChallengeUnion::get_diffie_hellman, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoChallengeUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoChallengeUnion { + fn clear(&mut self) { + self.clear_diffie_hellman(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoChallengeUnion { + fn eq(&self, other: &LoginCryptoChallengeUnion) -> bool { + self.diffie_hellman == other.diffie_hellman && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoChallengeUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoDiffieHellmanChallenge { + // message fields + gs: ::protobuf::SingularField<::std::vec::Vec>, + server_signature_key: ::std::option::Option, + gs_signature: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoDiffieHellmanChallenge {} + +impl LoginCryptoDiffieHellmanChallenge { + pub fn new() -> LoginCryptoDiffieHellmanChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoDiffieHellmanChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoDiffieHellmanChallenge, + }; + unsafe { + instance.get(|| { + LoginCryptoDiffieHellmanChallenge { + gs: ::protobuf::SingularField::none(), + server_signature_key: ::std::option::Option::None, + gs_signature: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes gs = 10; + + pub fn clear_gs(&mut self) { + self.gs.clear(); + } + + pub fn has_gs(&self) -> bool { + self.gs.is_some() + } + + // Param is passed by value, moved + pub fn set_gs(&mut self, v: ::std::vec::Vec) { + self.gs = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gs(&mut self) -> &mut ::std::vec::Vec { + if self.gs.is_none() { + self.gs.set_default(); + }; + self.gs.as_mut().unwrap() + } + + // Take field + pub fn take_gs(&mut self) -> ::std::vec::Vec { + self.gs.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gs(&self) -> &[u8] { + match self.gs.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required int32 server_signature_key = 20; + + pub fn clear_server_signature_key(&mut self) { + self.server_signature_key = ::std::option::Option::None; + } + + pub fn has_server_signature_key(&self) -> bool { + self.server_signature_key.is_some() + } + + // Param is passed by value, moved + pub fn set_server_signature_key(&mut self, v: i32) { + self.server_signature_key = ::std::option::Option::Some(v); + } + + pub fn get_server_signature_key(&self) -> i32 { + self.server_signature_key.unwrap_or(0) + } + + // required bytes gs_signature = 30; + + pub fn clear_gs_signature(&mut self) { + self.gs_signature.clear(); + } + + pub fn has_gs_signature(&self) -> bool { + self.gs_signature.is_some() + } + + // Param is passed by value, moved + pub fn set_gs_signature(&mut self, v: ::std::vec::Vec) { + self.gs_signature = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gs_signature(&mut self) -> &mut ::std::vec::Vec { + if self.gs_signature.is_none() { + self.gs_signature.set_default(); + }; + self.gs_signature.as_mut().unwrap() + } + + // Take field + pub fn take_gs_signature(&mut self) -> ::std::vec::Vec { + self.gs_signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gs_signature(&self) -> &[u8] { + match self.gs_signature.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for LoginCryptoDiffieHellmanChallenge { + fn is_initialized(&self) -> bool { + if self.gs.is_none() { + return false; + }; + if self.server_signature_key.is_none() { + return false; + }; + if self.gs_signature.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gs)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.server_signature_key = ::std::option::Option::Some(tmp); + }, + 30 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gs_signature)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gs { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + for value in &self.server_signature_key { + my_size += ::protobuf::rt::value_size(20, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.gs_signature { + my_size += ::protobuf::rt::bytes_size(30, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gs.as_ref() { + try!(os.write_bytes(10, &v)); + }; + if let Some(v) = self.server_signature_key { + try!(os.write_int32(20, v)); + }; + if let Some(v) = self.gs_signature.as_ref() { + try!(os.write_bytes(30, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoDiffieHellmanChallenge { + fn new() -> LoginCryptoDiffieHellmanChallenge { + LoginCryptoDiffieHellmanChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gs", + LoginCryptoDiffieHellmanChallenge::has_gs, + LoginCryptoDiffieHellmanChallenge::get_gs, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "server_signature_key", + LoginCryptoDiffieHellmanChallenge::has_server_signature_key, + LoginCryptoDiffieHellmanChallenge::get_server_signature_key, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gs_signature", + LoginCryptoDiffieHellmanChallenge::has_gs_signature, + LoginCryptoDiffieHellmanChallenge::get_gs_signature, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoDiffieHellmanChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoDiffieHellmanChallenge { + fn clear(&mut self) { + self.clear_gs(); + self.clear_server_signature_key(); + self.clear_gs_signature(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoDiffieHellmanChallenge { + fn eq(&self, other: &LoginCryptoDiffieHellmanChallenge) -> bool { + self.gs == other.gs && + self.server_signature_key == other.server_signature_key && + self.gs_signature == other.gs_signature && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoDiffieHellmanChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintChallengeUnion { + // message fields + grain: ::protobuf::SingularPtrField, + hmac_ripemd: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintChallengeUnion {} + +impl FingerprintChallengeUnion { + pub fn new() -> FingerprintChallengeUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintChallengeUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintChallengeUnion, + }; + unsafe { + instance.get(|| { + FingerprintChallengeUnion { + grain: ::protobuf::SingularPtrField::none(), + hmac_ripemd: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .FingerprintGrainChallenge grain = 10; + + pub fn clear_grain(&mut self) { + self.grain.clear(); + } + + pub fn has_grain(&self) -> bool { + self.grain.is_some() + } + + // Param is passed by value, moved + pub fn set_grain(&mut self, v: FingerprintGrainChallenge) { + self.grain = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_grain(&mut self) -> &mut FingerprintGrainChallenge { + if self.grain.is_none() { + self.grain.set_default(); + }; + self.grain.as_mut().unwrap() + } + + // Take field + pub fn take_grain(&mut self) -> FingerprintGrainChallenge { + self.grain.take().unwrap_or_else(|| FingerprintGrainChallenge::new()) + } + + pub fn get_grain(&self) -> &FingerprintGrainChallenge { + self.grain.as_ref().unwrap_or_else(|| FingerprintGrainChallenge::default_instance()) + } + + // optional .FingerprintHmacRipemdChallenge hmac_ripemd = 20; + + pub fn clear_hmac_ripemd(&mut self) { + self.hmac_ripemd.clear(); + } + + pub fn has_hmac_ripemd(&self) -> bool { + self.hmac_ripemd.is_some() + } + + // Param is passed by value, moved + pub fn set_hmac_ripemd(&mut self, v: FingerprintHmacRipemdChallenge) { + self.hmac_ripemd = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hmac_ripemd(&mut self) -> &mut FingerprintHmacRipemdChallenge { + if self.hmac_ripemd.is_none() { + self.hmac_ripemd.set_default(); + }; + self.hmac_ripemd.as_mut().unwrap() + } + + // Take field + pub fn take_hmac_ripemd(&mut self) -> FingerprintHmacRipemdChallenge { + self.hmac_ripemd.take().unwrap_or_else(|| FingerprintHmacRipemdChallenge::new()) + } + + pub fn get_hmac_ripemd(&self) -> &FingerprintHmacRipemdChallenge { + self.hmac_ripemd.as_ref().unwrap_or_else(|| FingerprintHmacRipemdChallenge::default_instance()) + } +} + +impl ::protobuf::Message for FingerprintChallengeUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.grain)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.hmac_ripemd)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.grain { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.hmac_ripemd { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.grain.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.hmac_ripemd.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintChallengeUnion { + fn new() -> FingerprintChallengeUnion { + FingerprintChallengeUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "grain", + FingerprintChallengeUnion::has_grain, + FingerprintChallengeUnion::get_grain, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "hmac_ripemd", + FingerprintChallengeUnion::has_hmac_ripemd, + FingerprintChallengeUnion::get_hmac_ripemd, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintChallengeUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintChallengeUnion { + fn clear(&mut self) { + self.clear_grain(); + self.clear_hmac_ripemd(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintChallengeUnion { + fn eq(&self, other: &FingerprintChallengeUnion) -> bool { + self.grain == other.grain && + self.hmac_ripemd == other.hmac_ripemd && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintChallengeUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintGrainChallenge { + // message fields + kek: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintGrainChallenge {} + +impl FingerprintGrainChallenge { + pub fn new() -> FingerprintGrainChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintGrainChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintGrainChallenge, + }; + unsafe { + instance.get(|| { + FingerprintGrainChallenge { + kek: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes kek = 10; + + pub fn clear_kek(&mut self) { + self.kek.clear(); + } + + pub fn has_kek(&self) -> bool { + self.kek.is_some() + } + + // Param is passed by value, moved + pub fn set_kek(&mut self, v: ::std::vec::Vec) { + self.kek = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_kek(&mut self) -> &mut ::std::vec::Vec { + if self.kek.is_none() { + self.kek.set_default(); + }; + self.kek.as_mut().unwrap() + } + + // Take field + pub fn take_kek(&mut self) -> ::std::vec::Vec { + self.kek.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_kek(&self) -> &[u8] { + match self.kek.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for FingerprintGrainChallenge { + fn is_initialized(&self) -> bool { + if self.kek.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.kek)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.kek { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.kek.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintGrainChallenge { + fn new() -> FingerprintGrainChallenge { + FingerprintGrainChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "kek", + FingerprintGrainChallenge::has_kek, + FingerprintGrainChallenge::get_kek, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintGrainChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintGrainChallenge { + fn clear(&mut self) { + self.clear_kek(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintGrainChallenge { + fn eq(&self, other: &FingerprintGrainChallenge) -> bool { + self.kek == other.kek && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintGrainChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct FingerprintHmacRipemdChallenge { + // message fields + challenge: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for FingerprintHmacRipemdChallenge {} + +impl FingerprintHmacRipemdChallenge { + pub fn new() -> FingerprintHmacRipemdChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static FingerprintHmacRipemdChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const FingerprintHmacRipemdChallenge, + }; + unsafe { + instance.get(|| { + FingerprintHmacRipemdChallenge { + challenge: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes challenge = 10; + + pub fn clear_challenge(&mut self) { + self.challenge.clear(); + } + + pub fn has_challenge(&self) -> bool { + self.challenge.is_some() + } + + // Param is passed by value, moved + pub fn set_challenge(&mut self, v: ::std::vec::Vec) { + self.challenge = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_challenge(&mut self) -> &mut ::std::vec::Vec { + if self.challenge.is_none() { + self.challenge.set_default(); + }; + self.challenge.as_mut().unwrap() + } + + // Take field + pub fn take_challenge(&mut self) -> ::std::vec::Vec { + self.challenge.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_challenge(&self) -> &[u8] { + match self.challenge.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for FingerprintHmacRipemdChallenge { + fn is_initialized(&self) -> bool { + if self.challenge.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.challenge)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.challenge { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.challenge.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for FingerprintHmacRipemdChallenge { + fn new() -> FingerprintHmacRipemdChallenge { + FingerprintHmacRipemdChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "challenge", + FingerprintHmacRipemdChallenge::has_challenge, + FingerprintHmacRipemdChallenge::get_challenge, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "FingerprintHmacRipemdChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for FingerprintHmacRipemdChallenge { + fn clear(&mut self) { + self.clear_challenge(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for FingerprintHmacRipemdChallenge { + fn eq(&self, other: &FingerprintHmacRipemdChallenge) -> bool { + self.challenge == other.challenge && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for FingerprintHmacRipemdChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PoWChallengeUnion { + // message fields + hash_cash: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PoWChallengeUnion {} + +impl PoWChallengeUnion { + pub fn new() -> PoWChallengeUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PoWChallengeUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PoWChallengeUnion, + }; + unsafe { + instance.get(|| { + PoWChallengeUnion { + hash_cash: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .PoWHashCashChallenge hash_cash = 10; + + pub fn clear_hash_cash(&mut self) { + self.hash_cash.clear(); + } + + pub fn has_hash_cash(&self) -> bool { + self.hash_cash.is_some() + } + + // Param is passed by value, moved + pub fn set_hash_cash(&mut self, v: PoWHashCashChallenge) { + self.hash_cash = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hash_cash(&mut self) -> &mut PoWHashCashChallenge { + if self.hash_cash.is_none() { + self.hash_cash.set_default(); + }; + self.hash_cash.as_mut().unwrap() + } + + // Take field + pub fn take_hash_cash(&mut self) -> PoWHashCashChallenge { + self.hash_cash.take().unwrap_or_else(|| PoWHashCashChallenge::new()) + } + + pub fn get_hash_cash(&self) -> &PoWHashCashChallenge { + self.hash_cash.as_ref().unwrap_or_else(|| PoWHashCashChallenge::default_instance()) + } +} + +impl ::protobuf::Message for PoWChallengeUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.hash_cash)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.hash_cash { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.hash_cash.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PoWChallengeUnion { + fn new() -> PoWChallengeUnion { + PoWChallengeUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "hash_cash", + PoWChallengeUnion::has_hash_cash, + PoWChallengeUnion::get_hash_cash, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PoWChallengeUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PoWChallengeUnion { + fn clear(&mut self) { + self.clear_hash_cash(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PoWChallengeUnion { + fn eq(&self, other: &PoWChallengeUnion) -> bool { + self.hash_cash == other.hash_cash && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PoWChallengeUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PoWHashCashChallenge { + // message fields + prefix: ::protobuf::SingularField<::std::vec::Vec>, + length: ::std::option::Option, + target: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PoWHashCashChallenge {} + +impl PoWHashCashChallenge { + pub fn new() -> PoWHashCashChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PoWHashCashChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PoWHashCashChallenge, + }; + unsafe { + instance.get(|| { + PoWHashCashChallenge { + prefix: ::protobuf::SingularField::none(), + length: ::std::option::Option::None, + target: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes prefix = 10; + + pub fn clear_prefix(&mut self) { + self.prefix.clear(); + } + + pub fn has_prefix(&self) -> bool { + self.prefix.is_some() + } + + // Param is passed by value, moved + pub fn set_prefix(&mut self, v: ::std::vec::Vec) { + self.prefix = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_prefix(&mut self) -> &mut ::std::vec::Vec { + if self.prefix.is_none() { + self.prefix.set_default(); + }; + self.prefix.as_mut().unwrap() + } + + // Take field + pub fn take_prefix(&mut self) -> ::std::vec::Vec { + self.prefix.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_prefix(&self) -> &[u8] { + match self.prefix.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional int32 length = 20; + + pub fn clear_length(&mut self) { + self.length = ::std::option::Option::None; + } + + pub fn has_length(&self) -> bool { + self.length.is_some() + } + + // Param is passed by value, moved + pub fn set_length(&mut self, v: i32) { + self.length = ::std::option::Option::Some(v); + } + + pub fn get_length(&self) -> i32 { + self.length.unwrap_or(0) + } + + // optional int32 target = 30; + + pub fn clear_target(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_target(&self) -> bool { + self.target.is_some() + } + + // Param is passed by value, moved + pub fn set_target(&mut self, v: i32) { + self.target = ::std::option::Option::Some(v); + } + + pub fn get_target(&self) -> i32 { + self.target.unwrap_or(0) + } +} + +impl ::protobuf::Message for PoWHashCashChallenge { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.prefix)); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.length = ::std::option::Option::Some(tmp); + }, + 30 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.target = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.prefix { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + for value in &self.length { + my_size += ::protobuf::rt::value_size(20, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.target { + my_size += ::protobuf::rt::value_size(30, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.prefix.as_ref() { + try!(os.write_bytes(10, &v)); + }; + if let Some(v) = self.length { + try!(os.write_int32(20, v)); + }; + if let Some(v) = self.target { + try!(os.write_int32(30, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PoWHashCashChallenge { + fn new() -> PoWHashCashChallenge { + PoWHashCashChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "prefix", + PoWHashCashChallenge::has_prefix, + PoWHashCashChallenge::get_prefix, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "length", + PoWHashCashChallenge::has_length, + PoWHashCashChallenge::get_length, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "target", + PoWHashCashChallenge::has_target, + PoWHashCashChallenge::get_target, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PoWHashCashChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PoWHashCashChallenge { + fn clear(&mut self) { + self.clear_prefix(); + self.clear_length(); + self.clear_target(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PoWHashCashChallenge { + fn eq(&self, other: &PoWHashCashChallenge) -> bool { + self.prefix == other.prefix && + self.length == other.length && + self.target == other.target && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PoWHashCashChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoChallengeUnion { + // message fields + shannon: ::protobuf::SingularPtrField, + rc4_sha1_hmac: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoChallengeUnion {} + +impl CryptoChallengeUnion { + pub fn new() -> CryptoChallengeUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoChallengeUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoChallengeUnion, + }; + unsafe { + instance.get(|| { + CryptoChallengeUnion { + shannon: ::protobuf::SingularPtrField::none(), + rc4_sha1_hmac: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .CryptoShannonChallenge shannon = 10; + + pub fn clear_shannon(&mut self) { + self.shannon.clear(); + } + + pub fn has_shannon(&self) -> bool { + self.shannon.is_some() + } + + // Param is passed by value, moved + pub fn set_shannon(&mut self, v: CryptoShannonChallenge) { + self.shannon = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_shannon(&mut self) -> &mut CryptoShannonChallenge { + if self.shannon.is_none() { + self.shannon.set_default(); + }; + self.shannon.as_mut().unwrap() + } + + // Take field + pub fn take_shannon(&mut self) -> CryptoShannonChallenge { + self.shannon.take().unwrap_or_else(|| CryptoShannonChallenge::new()) + } + + pub fn get_shannon(&self) -> &CryptoShannonChallenge { + self.shannon.as_ref().unwrap_or_else(|| CryptoShannonChallenge::default_instance()) + } + + // optional .CryptoRc4Sha1HmacChallenge rc4_sha1_hmac = 20; + + pub fn clear_rc4_sha1_hmac(&mut self) { + self.rc4_sha1_hmac.clear(); + } + + pub fn has_rc4_sha1_hmac(&self) -> bool { + self.rc4_sha1_hmac.is_some() + } + + // Param is passed by value, moved + pub fn set_rc4_sha1_hmac(&mut self, v: CryptoRc4Sha1HmacChallenge) { + self.rc4_sha1_hmac = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_rc4_sha1_hmac(&mut self) -> &mut CryptoRc4Sha1HmacChallenge { + if self.rc4_sha1_hmac.is_none() { + self.rc4_sha1_hmac.set_default(); + }; + self.rc4_sha1_hmac.as_mut().unwrap() + } + + // Take field + pub fn take_rc4_sha1_hmac(&mut self) -> CryptoRc4Sha1HmacChallenge { + self.rc4_sha1_hmac.take().unwrap_or_else(|| CryptoRc4Sha1HmacChallenge::new()) + } + + pub fn get_rc4_sha1_hmac(&self) -> &CryptoRc4Sha1HmacChallenge { + self.rc4_sha1_hmac.as_ref().unwrap_or_else(|| CryptoRc4Sha1HmacChallenge::default_instance()) + } +} + +impl ::protobuf::Message for CryptoChallengeUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shannon)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.rc4_sha1_hmac)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.shannon { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.rc4_sha1_hmac { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.shannon.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.rc4_sha1_hmac.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoChallengeUnion { + fn new() -> CryptoChallengeUnion { + CryptoChallengeUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "shannon", + CryptoChallengeUnion::has_shannon, + CryptoChallengeUnion::get_shannon, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "rc4_sha1_hmac", + CryptoChallengeUnion::has_rc4_sha1_hmac, + CryptoChallengeUnion::get_rc4_sha1_hmac, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoChallengeUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoChallengeUnion { + fn clear(&mut self) { + self.clear_shannon(); + self.clear_rc4_sha1_hmac(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoChallengeUnion { + fn eq(&self, other: &CryptoChallengeUnion) -> bool { + self.shannon == other.shannon && + self.rc4_sha1_hmac == other.rc4_sha1_hmac && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoChallengeUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoShannonChallenge { + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoShannonChallenge {} + +impl CryptoShannonChallenge { + pub fn new() -> CryptoShannonChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoShannonChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoShannonChallenge, + }; + unsafe { + instance.get(|| { + CryptoShannonChallenge { + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } +} + +impl ::protobuf::Message for CryptoShannonChallenge { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoShannonChallenge { + fn new() -> CryptoShannonChallenge { + CryptoShannonChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoShannonChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoShannonChallenge { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoShannonChallenge { + fn eq(&self, other: &CryptoShannonChallenge) -> bool { + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoShannonChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoRc4Sha1HmacChallenge { + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoRc4Sha1HmacChallenge {} + +impl CryptoRc4Sha1HmacChallenge { + pub fn new() -> CryptoRc4Sha1HmacChallenge { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoRc4Sha1HmacChallenge { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoRc4Sha1HmacChallenge, + }; + unsafe { + instance.get(|| { + CryptoRc4Sha1HmacChallenge { + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } +} + +impl ::protobuf::Message for CryptoRc4Sha1HmacChallenge { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoRc4Sha1HmacChallenge { + fn new() -> CryptoRc4Sha1HmacChallenge { + CryptoRc4Sha1HmacChallenge::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoRc4Sha1HmacChallenge", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoRc4Sha1HmacChallenge { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoRc4Sha1HmacChallenge { + fn eq(&self, other: &CryptoRc4Sha1HmacChallenge) -> bool { + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoRc4Sha1HmacChallenge { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct UpgradeRequiredMessage { + // message fields + upgrade_signed_part: ::protobuf::SingularField<::std::vec::Vec>, + signature: ::protobuf::SingularField<::std::vec::Vec>, + http_suffix: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for UpgradeRequiredMessage {} + +impl UpgradeRequiredMessage { + pub fn new() -> UpgradeRequiredMessage { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static UpgradeRequiredMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpgradeRequiredMessage, + }; + unsafe { + instance.get(|| { + UpgradeRequiredMessage { + upgrade_signed_part: ::protobuf::SingularField::none(), + signature: ::protobuf::SingularField::none(), + http_suffix: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes upgrade_signed_part = 10; + + pub fn clear_upgrade_signed_part(&mut self) { + self.upgrade_signed_part.clear(); + } + + pub fn has_upgrade_signed_part(&self) -> bool { + self.upgrade_signed_part.is_some() + } + + // Param is passed by value, moved + pub fn set_upgrade_signed_part(&mut self, v: ::std::vec::Vec) { + self.upgrade_signed_part = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_upgrade_signed_part(&mut self) -> &mut ::std::vec::Vec { + if self.upgrade_signed_part.is_none() { + self.upgrade_signed_part.set_default(); + }; + self.upgrade_signed_part.as_mut().unwrap() + } + + // Take field + pub fn take_upgrade_signed_part(&mut self) -> ::std::vec::Vec { + self.upgrade_signed_part.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_upgrade_signed_part(&self) -> &[u8] { + match self.upgrade_signed_part.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // required bytes signature = 20; + + pub fn clear_signature(&mut self) { + self.signature.clear(); + } + + pub fn has_signature(&self) -> bool { + self.signature.is_some() + } + + // Param is passed by value, moved + pub fn set_signature(&mut self, v: ::std::vec::Vec) { + self.signature = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec { + if self.signature.is_none() { + self.signature.set_default(); + }; + self.signature.as_mut().unwrap() + } + + // Take field + pub fn take_signature(&mut self) -> ::std::vec::Vec { + self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_signature(&self) -> &[u8] { + match self.signature.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string http_suffix = 30; + + pub fn clear_http_suffix(&mut self) { + self.http_suffix.clear(); + } + + pub fn has_http_suffix(&self) -> bool { + self.http_suffix.is_some() + } + + // Param is passed by value, moved + pub fn set_http_suffix(&mut self, v: ::std::string::String) { + self.http_suffix = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_http_suffix(&mut self) -> &mut ::std::string::String { + if self.http_suffix.is_none() { + self.http_suffix.set_default(); + }; + self.http_suffix.as_mut().unwrap() + } + + // Take field + pub fn take_http_suffix(&mut self) -> ::std::string::String { + self.http_suffix.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_http_suffix(&self) -> &str { + match self.http_suffix.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for UpgradeRequiredMessage { + fn is_initialized(&self) -> bool { + if self.upgrade_signed_part.is_none() { + return false; + }; + if self.signature.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.upgrade_signed_part)); + }, + 20 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)); + }, + 30 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.http_suffix)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.upgrade_signed_part { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + for value in &self.signature { + my_size += ::protobuf::rt::bytes_size(20, &value); + }; + for value in &self.http_suffix { + my_size += ::protobuf::rt::string_size(30, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.upgrade_signed_part.as_ref() { + try!(os.write_bytes(10, &v)); + }; + if let Some(v) = self.signature.as_ref() { + try!(os.write_bytes(20, &v)); + }; + if let Some(v) = self.http_suffix.as_ref() { + try!(os.write_string(30, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for UpgradeRequiredMessage { + fn new() -> UpgradeRequiredMessage { + UpgradeRequiredMessage::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "upgrade_signed_part", + UpgradeRequiredMessage::has_upgrade_signed_part, + UpgradeRequiredMessage::get_upgrade_signed_part, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "signature", + UpgradeRequiredMessage::has_signature, + UpgradeRequiredMessage::get_signature, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "http_suffix", + UpgradeRequiredMessage::has_http_suffix, + UpgradeRequiredMessage::get_http_suffix, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpgradeRequiredMessage", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for UpgradeRequiredMessage { + fn clear(&mut self) { + self.clear_upgrade_signed_part(); + self.clear_signature(); + self.clear_http_suffix(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for UpgradeRequiredMessage { + fn eq(&self, other: &UpgradeRequiredMessage) -> bool { + self.upgrade_signed_part == other.upgrade_signed_part && + self.signature == other.signature && + self.http_suffix == other.http_suffix && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for UpgradeRequiredMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct APLoginFailed { + // message fields + error_code: ::std::option::Option, + retry_delay: ::std::option::Option, + expiry: ::std::option::Option, + error_description: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for APLoginFailed {} + +impl APLoginFailed { + pub fn new() -> APLoginFailed { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static APLoginFailed { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const APLoginFailed, + }; + unsafe { + instance.get(|| { + APLoginFailed { + error_code: ::std::option::Option::None, + retry_delay: ::std::option::Option::None, + expiry: ::std::option::Option::None, + error_description: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .ErrorCode error_code = 10; + + pub fn clear_error_code(&mut self) { + self.error_code = ::std::option::Option::None; + } + + pub fn has_error_code(&self) -> bool { + self.error_code.is_some() + } + + // Param is passed by value, moved + pub fn set_error_code(&mut self, v: ErrorCode) { + self.error_code = ::std::option::Option::Some(v); + } + + pub fn get_error_code(&self) -> ErrorCode { + self.error_code.unwrap_or(ErrorCode::ProtocolError) + } + + // optional int32 retry_delay = 20; + + pub fn clear_retry_delay(&mut self) { + self.retry_delay = ::std::option::Option::None; + } + + pub fn has_retry_delay(&self) -> bool { + self.retry_delay.is_some() + } + + // Param is passed by value, moved + pub fn set_retry_delay(&mut self, v: i32) { + self.retry_delay = ::std::option::Option::Some(v); + } + + pub fn get_retry_delay(&self) -> i32 { + self.retry_delay.unwrap_or(0) + } + + // optional int32 expiry = 30; + + pub fn clear_expiry(&mut self) { + self.expiry = ::std::option::Option::None; + } + + pub fn has_expiry(&self) -> bool { + self.expiry.is_some() + } + + // Param is passed by value, moved + pub fn set_expiry(&mut self, v: i32) { + self.expiry = ::std::option::Option::Some(v); + } + + pub fn get_expiry(&self) -> i32 { + self.expiry.unwrap_or(0) + } + + // optional string error_description = 40; + + pub fn clear_error_description(&mut self) { + self.error_description.clear(); + } + + pub fn has_error_description(&self) -> bool { + self.error_description.is_some() + } + + // Param is passed by value, moved + pub fn set_error_description(&mut self, v: ::std::string::String) { + self.error_description = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_error_description(&mut self) -> &mut ::std::string::String { + if self.error_description.is_none() { + self.error_description.set_default(); + }; + self.error_description.as_mut().unwrap() + } + + // Take field + pub fn take_error_description(&mut self) -> ::std::string::String { + self.error_description.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_error_description(&self) -> &str { + match self.error_description.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for APLoginFailed { + fn is_initialized(&self) -> bool { + if self.error_code.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.error_code = ::std::option::Option::Some(tmp); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.retry_delay = ::std::option::Option::Some(tmp); + }, + 30 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.expiry = ::std::option::Option::Some(tmp); + }, + 40 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.error_description)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.error_code { + my_size += ::protobuf::rt::enum_size(10, *value); + }; + for value in &self.retry_delay { + my_size += ::protobuf::rt::value_size(20, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.expiry { + my_size += ::protobuf::rt::value_size(30, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.error_description { + my_size += ::protobuf::rt::string_size(40, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.error_code { + try!(os.write_enum(10, v.value())); + }; + if let Some(v) = self.retry_delay { + try!(os.write_int32(20, v)); + }; + if let Some(v) = self.expiry { + try!(os.write_int32(30, v)); + }; + if let Some(v) = self.error_description.as_ref() { + try!(os.write_string(40, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for APLoginFailed { + fn new() -> APLoginFailed { + APLoginFailed::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "error_code", + APLoginFailed::has_error_code, + APLoginFailed::get_error_code, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "retry_delay", + APLoginFailed::has_retry_delay, + APLoginFailed::get_retry_delay, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "expiry", + APLoginFailed::has_expiry, + APLoginFailed::get_expiry, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "error_description", + APLoginFailed::has_error_description, + APLoginFailed::get_error_description, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "APLoginFailed", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for APLoginFailed { + fn clear(&mut self) { + self.clear_error_code(); + self.clear_retry_delay(); + self.clear_expiry(); + self.clear_error_description(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for APLoginFailed { + fn eq(&self, other: &APLoginFailed) -> bool { + self.error_code == other.error_code && + self.retry_delay == other.retry_delay && + self.expiry == other.expiry && + self.error_description == other.error_description && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for APLoginFailed { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct ClientResponsePlaintext { + // message fields + login_crypto_response: ::protobuf::SingularPtrField, + pow_response: ::protobuf::SingularPtrField, + crypto_response: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ClientResponsePlaintext {} + +impl ClientResponsePlaintext { + pub fn new() -> ClientResponsePlaintext { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ClientResponsePlaintext { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ClientResponsePlaintext, + }; + unsafe { + instance.get(|| { + ClientResponsePlaintext { + login_crypto_response: ::protobuf::SingularPtrField::none(), + pow_response: ::protobuf::SingularPtrField::none(), + crypto_response: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required .LoginCryptoResponseUnion login_crypto_response = 10; + + pub fn clear_login_crypto_response(&mut self) { + self.login_crypto_response.clear(); + } + + pub fn has_login_crypto_response(&self) -> bool { + self.login_crypto_response.is_some() + } + + // Param is passed by value, moved + pub fn set_login_crypto_response(&mut self, v: LoginCryptoResponseUnion) { + self.login_crypto_response = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_login_crypto_response(&mut self) -> &mut LoginCryptoResponseUnion { + if self.login_crypto_response.is_none() { + self.login_crypto_response.set_default(); + }; + self.login_crypto_response.as_mut().unwrap() + } + + // Take field + pub fn take_login_crypto_response(&mut self) -> LoginCryptoResponseUnion { + self.login_crypto_response.take().unwrap_or_else(|| LoginCryptoResponseUnion::new()) + } + + pub fn get_login_crypto_response(&self) -> &LoginCryptoResponseUnion { + self.login_crypto_response.as_ref().unwrap_or_else(|| LoginCryptoResponseUnion::default_instance()) + } + + // required .PoWResponseUnion pow_response = 20; + + pub fn clear_pow_response(&mut self) { + self.pow_response.clear(); + } + + pub fn has_pow_response(&self) -> bool { + self.pow_response.is_some() + } + + // Param is passed by value, moved + pub fn set_pow_response(&mut self, v: PoWResponseUnion) { + self.pow_response = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_pow_response(&mut self) -> &mut PoWResponseUnion { + if self.pow_response.is_none() { + self.pow_response.set_default(); + }; + self.pow_response.as_mut().unwrap() + } + + // Take field + pub fn take_pow_response(&mut self) -> PoWResponseUnion { + self.pow_response.take().unwrap_or_else(|| PoWResponseUnion::new()) + } + + pub fn get_pow_response(&self) -> &PoWResponseUnion { + self.pow_response.as_ref().unwrap_or_else(|| PoWResponseUnion::default_instance()) + } + + // required .CryptoResponseUnion crypto_response = 30; + + pub fn clear_crypto_response(&mut self) { + self.crypto_response.clear(); + } + + pub fn has_crypto_response(&self) -> bool { + self.crypto_response.is_some() + } + + // Param is passed by value, moved + pub fn set_crypto_response(&mut self, v: CryptoResponseUnion) { + self.crypto_response = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_crypto_response(&mut self) -> &mut CryptoResponseUnion { + if self.crypto_response.is_none() { + self.crypto_response.set_default(); + }; + self.crypto_response.as_mut().unwrap() + } + + // Take field + pub fn take_crypto_response(&mut self) -> CryptoResponseUnion { + self.crypto_response.take().unwrap_or_else(|| CryptoResponseUnion::new()) + } + + pub fn get_crypto_response(&self) -> &CryptoResponseUnion { + self.crypto_response.as_ref().unwrap_or_else(|| CryptoResponseUnion::default_instance()) + } +} + +impl ::protobuf::Message for ClientResponsePlaintext { + fn is_initialized(&self) -> bool { + if self.login_crypto_response.is_none() { + return false; + }; + if self.pow_response.is_none() { + return false; + }; + if self.crypto_response.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_crypto_response)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pow_response)); + }, + 30 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.crypto_response)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.login_crypto_response { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.pow_response { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.crypto_response { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.login_crypto_response.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.pow_response.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.crypto_response.as_ref() { + try!(os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ClientResponsePlaintext { + fn new() -> ClientResponsePlaintext { + ClientResponsePlaintext::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "login_crypto_response", + ClientResponsePlaintext::has_login_crypto_response, + ClientResponsePlaintext::get_login_crypto_response, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "pow_response", + ClientResponsePlaintext::has_pow_response, + ClientResponsePlaintext::get_pow_response, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "crypto_response", + ClientResponsePlaintext::has_crypto_response, + ClientResponsePlaintext::get_crypto_response, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ClientResponsePlaintext", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ClientResponsePlaintext { + fn clear(&mut self) { + self.clear_login_crypto_response(); + self.clear_pow_response(); + self.clear_crypto_response(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ClientResponsePlaintext { + fn eq(&self, other: &ClientResponsePlaintext) -> bool { + self.login_crypto_response == other.login_crypto_response && + self.pow_response == other.pow_response && + self.crypto_response == other.crypto_response && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ClientResponsePlaintext { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoResponseUnion { + // message fields + diffie_hellman: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoResponseUnion {} + +impl LoginCryptoResponseUnion { + pub fn new() -> LoginCryptoResponseUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoResponseUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoResponseUnion, + }; + unsafe { + instance.get(|| { + LoginCryptoResponseUnion { + diffie_hellman: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .LoginCryptoDiffieHellmanResponse diffie_hellman = 10; + + pub fn clear_diffie_hellman(&mut self) { + self.diffie_hellman.clear(); + } + + pub fn has_diffie_hellman(&self) -> bool { + self.diffie_hellman.is_some() + } + + // Param is passed by value, moved + pub fn set_diffie_hellman(&mut self, v: LoginCryptoDiffieHellmanResponse) { + self.diffie_hellman = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_diffie_hellman(&mut self) -> &mut LoginCryptoDiffieHellmanResponse { + if self.diffie_hellman.is_none() { + self.diffie_hellman.set_default(); + }; + self.diffie_hellman.as_mut().unwrap() + } + + // Take field + pub fn take_diffie_hellman(&mut self) -> LoginCryptoDiffieHellmanResponse { + self.diffie_hellman.take().unwrap_or_else(|| LoginCryptoDiffieHellmanResponse::new()) + } + + pub fn get_diffie_hellman(&self) -> &LoginCryptoDiffieHellmanResponse { + self.diffie_hellman.as_ref().unwrap_or_else(|| LoginCryptoDiffieHellmanResponse::default_instance()) + } +} + +impl ::protobuf::Message for LoginCryptoResponseUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.diffie_hellman)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.diffie_hellman { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.diffie_hellman.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoResponseUnion { + fn new() -> LoginCryptoResponseUnion { + LoginCryptoResponseUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "diffie_hellman", + LoginCryptoResponseUnion::has_diffie_hellman, + LoginCryptoResponseUnion::get_diffie_hellman, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoResponseUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoResponseUnion { + fn clear(&mut self) { + self.clear_diffie_hellman(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoResponseUnion { + fn eq(&self, other: &LoginCryptoResponseUnion) -> bool { + self.diffie_hellman == other.diffie_hellman && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoResponseUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct LoginCryptoDiffieHellmanResponse { + // message fields + hmac: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for LoginCryptoDiffieHellmanResponse {} + +impl LoginCryptoDiffieHellmanResponse { + pub fn new() -> LoginCryptoDiffieHellmanResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static LoginCryptoDiffieHellmanResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LoginCryptoDiffieHellmanResponse, + }; + unsafe { + instance.get(|| { + LoginCryptoDiffieHellmanResponse { + hmac: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes hmac = 10; + + pub fn clear_hmac(&mut self) { + self.hmac.clear(); + } + + pub fn has_hmac(&self) -> bool { + self.hmac.is_some() + } + + // Param is passed by value, moved + pub fn set_hmac(&mut self, v: ::std::vec::Vec) { + self.hmac = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hmac(&mut self) -> &mut ::std::vec::Vec { + if self.hmac.is_none() { + self.hmac.set_default(); + }; + self.hmac.as_mut().unwrap() + } + + // Take field + pub fn take_hmac(&mut self) -> ::std::vec::Vec { + self.hmac.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_hmac(&self) -> &[u8] { + match self.hmac.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for LoginCryptoDiffieHellmanResponse { + fn is_initialized(&self) -> bool { + if self.hmac.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.hmac)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.hmac { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.hmac.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for LoginCryptoDiffieHellmanResponse { + fn new() -> LoginCryptoDiffieHellmanResponse { + LoginCryptoDiffieHellmanResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "hmac", + LoginCryptoDiffieHellmanResponse::has_hmac, + LoginCryptoDiffieHellmanResponse::get_hmac, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LoginCryptoDiffieHellmanResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for LoginCryptoDiffieHellmanResponse { + fn clear(&mut self) { + self.clear_hmac(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for LoginCryptoDiffieHellmanResponse { + fn eq(&self, other: &LoginCryptoDiffieHellmanResponse) -> bool { + self.hmac == other.hmac && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for LoginCryptoDiffieHellmanResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PoWResponseUnion { + // message fields + hash_cash: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PoWResponseUnion {} + +impl PoWResponseUnion { + pub fn new() -> PoWResponseUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PoWResponseUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PoWResponseUnion, + }; + unsafe { + instance.get(|| { + PoWResponseUnion { + hash_cash: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .PoWHashCashResponse hash_cash = 10; + + pub fn clear_hash_cash(&mut self) { + self.hash_cash.clear(); + } + + pub fn has_hash_cash(&self) -> bool { + self.hash_cash.is_some() + } + + // Param is passed by value, moved + pub fn set_hash_cash(&mut self, v: PoWHashCashResponse) { + self.hash_cash = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hash_cash(&mut self) -> &mut PoWHashCashResponse { + if self.hash_cash.is_none() { + self.hash_cash.set_default(); + }; + self.hash_cash.as_mut().unwrap() + } + + // Take field + pub fn take_hash_cash(&mut self) -> PoWHashCashResponse { + self.hash_cash.take().unwrap_or_else(|| PoWHashCashResponse::new()) + } + + pub fn get_hash_cash(&self) -> &PoWHashCashResponse { + self.hash_cash.as_ref().unwrap_or_else(|| PoWHashCashResponse::default_instance()) + } +} + +impl ::protobuf::Message for PoWResponseUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.hash_cash)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.hash_cash { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.hash_cash.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PoWResponseUnion { + fn new() -> PoWResponseUnion { + PoWResponseUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "hash_cash", + PoWResponseUnion::has_hash_cash, + PoWResponseUnion::get_hash_cash, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PoWResponseUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PoWResponseUnion { + fn clear(&mut self) { + self.clear_hash_cash(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PoWResponseUnion { + fn eq(&self, other: &PoWResponseUnion) -> bool { + self.hash_cash == other.hash_cash && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PoWResponseUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct PoWHashCashResponse { + // message fields + hash_suffix: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for PoWHashCashResponse {} + +impl PoWHashCashResponse { + pub fn new() -> PoWHashCashResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static PoWHashCashResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PoWHashCashResponse, + }; + unsafe { + instance.get(|| { + PoWHashCashResponse { + hash_suffix: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // required bytes hash_suffix = 10; + + pub fn clear_hash_suffix(&mut self) { + self.hash_suffix.clear(); + } + + pub fn has_hash_suffix(&self) -> bool { + self.hash_suffix.is_some() + } + + // Param is passed by value, moved + pub fn set_hash_suffix(&mut self, v: ::std::vec::Vec) { + self.hash_suffix = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_hash_suffix(&mut self) -> &mut ::std::vec::Vec { + if self.hash_suffix.is_none() { + self.hash_suffix.set_default(); + }; + self.hash_suffix.as_mut().unwrap() + } + + // Take field + pub fn take_hash_suffix(&mut self) -> ::std::vec::Vec { + self.hash_suffix.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_hash_suffix(&self) -> &[u8] { + match self.hash_suffix.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for PoWHashCashResponse { + fn is_initialized(&self) -> bool { + if self.hash_suffix.is_none() { + return false; + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.hash_suffix)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.hash_suffix { + my_size += ::protobuf::rt::bytes_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.hash_suffix.as_ref() { + try!(os.write_bytes(10, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for PoWHashCashResponse { + fn new() -> PoWHashCashResponse { + PoWHashCashResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "hash_suffix", + PoWHashCashResponse::has_hash_suffix, + PoWHashCashResponse::get_hash_suffix, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PoWHashCashResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for PoWHashCashResponse { + fn clear(&mut self) { + self.clear_hash_suffix(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for PoWHashCashResponse { + fn eq(&self, other: &PoWHashCashResponse) -> bool { + self.hash_suffix == other.hash_suffix && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for PoWHashCashResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoResponseUnion { + // message fields + shannon: ::protobuf::SingularPtrField, + rc4_sha1_hmac: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoResponseUnion {} + +impl CryptoResponseUnion { + pub fn new() -> CryptoResponseUnion { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoResponseUnion { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoResponseUnion, + }; + unsafe { + instance.get(|| { + CryptoResponseUnion { + shannon: ::protobuf::SingularPtrField::none(), + rc4_sha1_hmac: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .CryptoShannonResponse shannon = 10; + + pub fn clear_shannon(&mut self) { + self.shannon.clear(); + } + + pub fn has_shannon(&self) -> bool { + self.shannon.is_some() + } + + // Param is passed by value, moved + pub fn set_shannon(&mut self, v: CryptoShannonResponse) { + self.shannon = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_shannon(&mut self) -> &mut CryptoShannonResponse { + if self.shannon.is_none() { + self.shannon.set_default(); + }; + self.shannon.as_mut().unwrap() + } + + // Take field + pub fn take_shannon(&mut self) -> CryptoShannonResponse { + self.shannon.take().unwrap_or_else(|| CryptoShannonResponse::new()) + } + + pub fn get_shannon(&self) -> &CryptoShannonResponse { + self.shannon.as_ref().unwrap_or_else(|| CryptoShannonResponse::default_instance()) + } + + // optional .CryptoRc4Sha1HmacResponse rc4_sha1_hmac = 20; + + pub fn clear_rc4_sha1_hmac(&mut self) { + self.rc4_sha1_hmac.clear(); + } + + pub fn has_rc4_sha1_hmac(&self) -> bool { + self.rc4_sha1_hmac.is_some() + } + + // Param is passed by value, moved + pub fn set_rc4_sha1_hmac(&mut self, v: CryptoRc4Sha1HmacResponse) { + self.rc4_sha1_hmac = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_rc4_sha1_hmac(&mut self) -> &mut CryptoRc4Sha1HmacResponse { + if self.rc4_sha1_hmac.is_none() { + self.rc4_sha1_hmac.set_default(); + }; + self.rc4_sha1_hmac.as_mut().unwrap() + } + + // Take field + pub fn take_rc4_sha1_hmac(&mut self) -> CryptoRc4Sha1HmacResponse { + self.rc4_sha1_hmac.take().unwrap_or_else(|| CryptoRc4Sha1HmacResponse::new()) + } + + pub fn get_rc4_sha1_hmac(&self) -> &CryptoRc4Sha1HmacResponse { + self.rc4_sha1_hmac.as_ref().unwrap_or_else(|| CryptoRc4Sha1HmacResponse::default_instance()) + } +} + +impl ::protobuf::Message for CryptoResponseUnion { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 10 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shannon)); + }, + 20 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.rc4_sha1_hmac)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.shannon { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.rc4_sha1_hmac { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.shannon.as_ref() { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.rc4_sha1_hmac.as_ref() { + try!(os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoResponseUnion { + fn new() -> CryptoResponseUnion { + CryptoResponseUnion::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "shannon", + CryptoResponseUnion::has_shannon, + CryptoResponseUnion::get_shannon, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "rc4_sha1_hmac", + CryptoResponseUnion::has_rc4_sha1_hmac, + CryptoResponseUnion::get_rc4_sha1_hmac, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoResponseUnion", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoResponseUnion { + fn clear(&mut self) { + self.clear_shannon(); + self.clear_rc4_sha1_hmac(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoResponseUnion { + fn eq(&self, other: &CryptoResponseUnion) -> bool { + self.shannon == other.shannon && + self.rc4_sha1_hmac == other.rc4_sha1_hmac && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoResponseUnion { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoShannonResponse { + // message fields + dummy: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoShannonResponse {} + +impl CryptoShannonResponse { + pub fn new() -> CryptoShannonResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoShannonResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoShannonResponse, + }; + unsafe { + instance.get(|| { + CryptoShannonResponse { + dummy: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional int32 dummy = 1; + + pub fn clear_dummy(&mut self) { + self.dummy = ::std::option::Option::None; + } + + pub fn has_dummy(&self) -> bool { + self.dummy.is_some() + } + + // Param is passed by value, moved + pub fn set_dummy(&mut self, v: i32) { + self.dummy = ::std::option::Option::Some(v); + } + + pub fn get_dummy(&self) -> i32 { + self.dummy.unwrap_or(0) + } +} + +impl ::protobuf::Message for CryptoShannonResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.dummy = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.dummy { + my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.dummy { + try!(os.write_int32(1, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoShannonResponse { + fn new() -> CryptoShannonResponse { + CryptoShannonResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "dummy", + CryptoShannonResponse::has_dummy, + CryptoShannonResponse::get_dummy, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoShannonResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoShannonResponse { + fn clear(&mut self) { + self.clear_dummy(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoShannonResponse { + fn eq(&self, other: &CryptoShannonResponse) -> bool { + self.dummy == other.dummy && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoShannonResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct CryptoRc4Sha1HmacResponse { + // message fields + dummy: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for CryptoRc4Sha1HmacResponse {} + +impl CryptoRc4Sha1HmacResponse { + pub fn new() -> CryptoRc4Sha1HmacResponse { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static CryptoRc4Sha1HmacResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CryptoRc4Sha1HmacResponse, + }; + unsafe { + instance.get(|| { + CryptoRc4Sha1HmacResponse { + dummy: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional int32 dummy = 1; + + pub fn clear_dummy(&mut self) { + self.dummy = ::std::option::Option::None; + } + + pub fn has_dummy(&self) -> bool { + self.dummy.is_some() + } + + // Param is passed by value, moved + pub fn set_dummy(&mut self, v: i32) { + self.dummy = ::std::option::Option::Some(v); + } + + pub fn get_dummy(&self) -> i32 { + self.dummy.unwrap_or(0) + } +} + +impl ::protobuf::Message for CryptoRc4Sha1HmacResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.dummy = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.dummy { + my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.dummy { + try!(os.write_int32(1, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for CryptoRc4Sha1HmacResponse { + fn new() -> CryptoRc4Sha1HmacResponse { + CryptoRc4Sha1HmacResponse::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "dummy", + CryptoRc4Sha1HmacResponse::has_dummy, + CryptoRc4Sha1HmacResponse::get_dummy, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CryptoRc4Sha1HmacResponse", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for CryptoRc4Sha1HmacResponse { + fn clear(&mut self) { + self.clear_dummy(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for CryptoRc4Sha1HmacResponse { + fn eq(&self, other: &CryptoRc4Sha1HmacResponse) -> bool { + self.dummy == other.dummy && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for CryptoRc4Sha1HmacResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Product { + PRODUCT_CLIENT = 0, + PRODUCT_LIBSPOTIFY = 1, + PRODUCT_MOBILE = 2, + PRODUCT_PARTNER = 3, + PRODUCT_LIBSPOTIFY_EMBEDDED = 5, +} + +impl ::protobuf::ProtobufEnum for Product { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Product::PRODUCT_CLIENT), + 1 => ::std::option::Option::Some(Product::PRODUCT_LIBSPOTIFY), + 2 => ::std::option::Option::Some(Product::PRODUCT_MOBILE), + 3 => ::std::option::Option::Some(Product::PRODUCT_PARTNER), + 5 => ::std::option::Option::Some(Product::PRODUCT_LIBSPOTIFY_EMBEDDED), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Product] = &[ + Product::PRODUCT_CLIENT, + Product::PRODUCT_LIBSPOTIFY, + Product::PRODUCT_MOBILE, + Product::PRODUCT_PARTNER, + Product::PRODUCT_LIBSPOTIFY_EMBEDDED, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Product", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Product { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum ProductFlags { + PRODUCT_FLAG_NONE = 0, + PRODUCT_FLAG_DEV_BUILD = 1, +} + +impl ::protobuf::ProtobufEnum for ProductFlags { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(ProductFlags::PRODUCT_FLAG_NONE), + 1 => ::std::option::Option::Some(ProductFlags::PRODUCT_FLAG_DEV_BUILD), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [ProductFlags] = &[ + ProductFlags::PRODUCT_FLAG_NONE, + ProductFlags::PRODUCT_FLAG_DEV_BUILD, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("ProductFlags", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for ProductFlags { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Platform { + PLATFORM_WIN32_X86 = 0, + PLATFORM_OSX_X86 = 1, + PLATFORM_LINUX_X86 = 2, + PLATFORM_IPHONE_ARM = 3, + PLATFORM_S60_ARM = 4, + PLATFORM_OSX_PPC = 5, + PLATFORM_ANDROID_ARM = 6, + PLATFORM_WINDOWS_CE_ARM = 7, + PLATFORM_LINUX_X86_64 = 8, + PLATFORM_OSX_X86_64 = 9, + PLATFORM_PALM_ARM = 10, + PLATFORM_LINUX_SH = 11, + PLATFORM_FREEBSD_X86 = 12, + PLATFORM_FREEBSD_X86_64 = 13, + PLATFORM_BLACKBERRY_ARM = 14, + PLATFORM_SONOS = 15, + PLATFORM_LINUX_MIPS = 16, + PLATFORM_LINUX_ARM = 17, + PLATFORM_LOGITECH_ARM = 18, + PLATFORM_LINUX_BLACKFIN = 19, + PLATFORM_WP7_ARM = 20, + PLATFORM_ONKYO_ARM = 21, + PLATFORM_QNXNTO_ARM = 22, + PLATFORM_BCO_ARM = 23, +} + +impl ::protobuf::ProtobufEnum for Platform { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Platform::PLATFORM_WIN32_X86), + 1 => ::std::option::Option::Some(Platform::PLATFORM_OSX_X86), + 2 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_X86), + 3 => ::std::option::Option::Some(Platform::PLATFORM_IPHONE_ARM), + 4 => ::std::option::Option::Some(Platform::PLATFORM_S60_ARM), + 5 => ::std::option::Option::Some(Platform::PLATFORM_OSX_PPC), + 6 => ::std::option::Option::Some(Platform::PLATFORM_ANDROID_ARM), + 7 => ::std::option::Option::Some(Platform::PLATFORM_WINDOWS_CE_ARM), + 8 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_X86_64), + 9 => ::std::option::Option::Some(Platform::PLATFORM_OSX_X86_64), + 10 => ::std::option::Option::Some(Platform::PLATFORM_PALM_ARM), + 11 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_SH), + 12 => ::std::option::Option::Some(Platform::PLATFORM_FREEBSD_X86), + 13 => ::std::option::Option::Some(Platform::PLATFORM_FREEBSD_X86_64), + 14 => ::std::option::Option::Some(Platform::PLATFORM_BLACKBERRY_ARM), + 15 => ::std::option::Option::Some(Platform::PLATFORM_SONOS), + 16 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_MIPS), + 17 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_ARM), + 18 => ::std::option::Option::Some(Platform::PLATFORM_LOGITECH_ARM), + 19 => ::std::option::Option::Some(Platform::PLATFORM_LINUX_BLACKFIN), + 20 => ::std::option::Option::Some(Platform::PLATFORM_WP7_ARM), + 21 => ::std::option::Option::Some(Platform::PLATFORM_ONKYO_ARM), + 22 => ::std::option::Option::Some(Platform::PLATFORM_QNXNTO_ARM), + 23 => ::std::option::Option::Some(Platform::PLATFORM_BCO_ARM), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Platform] = &[ + Platform::PLATFORM_WIN32_X86, + Platform::PLATFORM_OSX_X86, + Platform::PLATFORM_LINUX_X86, + Platform::PLATFORM_IPHONE_ARM, + Platform::PLATFORM_S60_ARM, + Platform::PLATFORM_OSX_PPC, + Platform::PLATFORM_ANDROID_ARM, + Platform::PLATFORM_WINDOWS_CE_ARM, + Platform::PLATFORM_LINUX_X86_64, + Platform::PLATFORM_OSX_X86_64, + Platform::PLATFORM_PALM_ARM, + Platform::PLATFORM_LINUX_SH, + Platform::PLATFORM_FREEBSD_X86, + Platform::PLATFORM_FREEBSD_X86_64, + Platform::PLATFORM_BLACKBERRY_ARM, + Platform::PLATFORM_SONOS, + Platform::PLATFORM_LINUX_MIPS, + Platform::PLATFORM_LINUX_ARM, + Platform::PLATFORM_LOGITECH_ARM, + Platform::PLATFORM_LINUX_BLACKFIN, + Platform::PLATFORM_WP7_ARM, + Platform::PLATFORM_ONKYO_ARM, + Platform::PLATFORM_QNXNTO_ARM, + Platform::PLATFORM_BCO_ARM, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Platform", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Platform { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Fingerprint { + FINGERPRINT_GRAIN = 0, + FINGERPRINT_HMAC_RIPEMD = 1, +} + +impl ::protobuf::ProtobufEnum for Fingerprint { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Fingerprint::FINGERPRINT_GRAIN), + 1 => ::std::option::Option::Some(Fingerprint::FINGERPRINT_HMAC_RIPEMD), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Fingerprint] = &[ + Fingerprint::FINGERPRINT_GRAIN, + Fingerprint::FINGERPRINT_HMAC_RIPEMD, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Fingerprint", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Fingerprint { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Cryptosuite { + CRYPTO_SUITE_SHANNON = 0, + CRYPTO_SUITE_RC4_SHA1_HMAC = 1, +} + +impl ::protobuf::ProtobufEnum for Cryptosuite { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Cryptosuite::CRYPTO_SUITE_SHANNON), + 1 => ::std::option::Option::Some(Cryptosuite::CRYPTO_SUITE_RC4_SHA1_HMAC), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Cryptosuite] = &[ + Cryptosuite::CRYPTO_SUITE_SHANNON, + Cryptosuite::CRYPTO_SUITE_RC4_SHA1_HMAC, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Cryptosuite", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Cryptosuite { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Powscheme { + POW_HASH_CASH = 0, +} + +impl ::protobuf::ProtobufEnum for Powscheme { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Powscheme::POW_HASH_CASH), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Powscheme] = &[ + Powscheme::POW_HASH_CASH, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Powscheme", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Powscheme { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum ErrorCode { + ProtocolError = 0, + TryAnotherAP = 2, + BadConnectionId = 5, + TravelRestriction = 9, + PremiumAccountRequired = 11, + BadCredentials = 12, + CouldNotValidateCredentials = 13, + AccountExists = 14, + ExtraVerificationRequired = 15, + InvalidAppKey = 16, + ApplicationBanned = 17, +} + +impl ::protobuf::ProtobufEnum for ErrorCode { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(ErrorCode::ProtocolError), + 2 => ::std::option::Option::Some(ErrorCode::TryAnotherAP), + 5 => ::std::option::Option::Some(ErrorCode::BadConnectionId), + 9 => ::std::option::Option::Some(ErrorCode::TravelRestriction), + 11 => ::std::option::Option::Some(ErrorCode::PremiumAccountRequired), + 12 => ::std::option::Option::Some(ErrorCode::BadCredentials), + 13 => ::std::option::Option::Some(ErrorCode::CouldNotValidateCredentials), + 14 => ::std::option::Option::Some(ErrorCode::AccountExists), + 15 => ::std::option::Option::Some(ErrorCode::ExtraVerificationRequired), + 16 => ::std::option::Option::Some(ErrorCode::InvalidAppKey), + 17 => ::std::option::Option::Some(ErrorCode::ApplicationBanned), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [ErrorCode] = &[ + ErrorCode::ProtocolError, + ErrorCode::TryAnotherAP, + ErrorCode::BadConnectionId, + ErrorCode::TravelRestriction, + ErrorCode::PremiumAccountRequired, + ErrorCode::BadCredentials, + ErrorCode::CouldNotValidateCredentials, + ErrorCode::AccountExists, + ErrorCode::ExtraVerificationRequired, + ErrorCode::InvalidAppKey, + ErrorCode::ApplicationBanned, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("ErrorCode", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for ErrorCode { +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x11, 0x6b, 0x65, 0x79, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xb2, 0x03, 0x0a, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, + 0x6c, 0x6c, 0x6f, 0x12, 0x29, 0x0a, 0x0a, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x43, + 0x0a, 0x16, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x73, 0x5f, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x0c, + 0x2e, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x15, 0x66, 0x69, + 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x12, 0x43, 0x0a, 0x16, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x73, 0x75, 0x69, + 0x74, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x1e, 0x20, + 0x03, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x73, 0x75, 0x69, 0x74, + 0x65, 0x52, 0x15, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x73, 0x75, 0x69, 0x74, 0x65, 0x73, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x14, 0x70, 0x6f, 0x77, 0x73, + 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, + 0x18, 0x28, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x0a, 0x2e, 0x50, 0x6f, 0x77, 0x73, 0x63, 0x68, 0x65, + 0x6d, 0x65, 0x52, 0x13, 0x70, 0x6f, 0x77, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x53, 0x75, + 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x44, 0x0a, 0x12, 0x6c, 0x6f, 0x67, 0x69, 0x6e, + 0x5f, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x18, 0x32, 0x20, + 0x02, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, + 0x6f, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x6c, 0x6f, 0x67, + 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x12, 0x21, 0x0a, + 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x3c, 0x20, + 0x02, 0x28, 0x0c, 0x52, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x6e, 0x63, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x46, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x07, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x0b, 0x66, 0x65, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0b, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x0a, 0x66, 0x65, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x22, 0xa4, 0x01, 0x0a, 0x09, 0x42, 0x75, 0x69, + 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, + 0x74, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x08, 0x2e, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, + 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x12, 0x32, 0x0a, 0x0d, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x74, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x14, 0x20, 0x03, 0x28, + 0x0e, 0x32, 0x0d, 0x2e, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, + 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x25, + 0x0a, 0x08, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x1e, 0x20, 0x02, 0x28, 0x0e, + 0x32, 0x09, 0x2e, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x52, 0x08, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x28, 0x20, 0x02, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, + 0x5e, 0x0a, 0x15, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x48, 0x65, + 0x6c, 0x6c, 0x6f, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x0e, 0x64, 0x69, 0x66, 0x66, + 0x69, 0x65, 0x5f, 0x68, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x44, 0x69, + 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, + 0x52, 0x0d, 0x64, 0x69, 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x22, + 0x5b, 0x0a, 0x1d, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x44, 0x69, + 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, + 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x63, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x02, 0x67, 0x63, + 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x5f, + 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0d, 0x52, 0x0f, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x59, 0x0a, 0x0a, + 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x61, 0x75, + 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x61, 0x75, 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x32, 0x12, 0x29, 0x0a, 0x10, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa5, 0x01, 0x0a, 0x11, 0x41, 0x50, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x0a, + 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0c, 0x2e, 0x41, 0x50, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x09, + 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, 0x31, 0x0a, 0x07, 0x75, 0x70, 0x67, + 0x72, 0x61, 0x64, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x55, 0x70, 0x67, + 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x52, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x12, 0x31, 0x0a, 0x0c, + 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x1e, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x41, 0x50, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x46, 0x61, 0x69, 0x6c, + 0x65, 0x64, 0x52, 0x0b, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x22, + 0xe8, 0x02, 0x0a, 0x0b, 0x41, 0x50, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, + 0x50, 0x0a, 0x16, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x5f, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, + 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x43, 0x68, 0x61, + 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x14, 0x6c, 0x6f, 0x67, + 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, + 0x65, 0x12, 0x4f, 0x0a, 0x15, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, + 0x5f, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x43, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x14, 0x66, 0x69, + 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, + 0x67, 0x65, 0x12, 0x37, 0x0a, 0x0d, 0x70, 0x6f, 0x77, 0x5f, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, + 0x6e, 0x67, 0x65, 0x18, 0x1e, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x50, 0x6f, 0x57, 0x43, + 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x70, + 0x6f, 0x77, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, 0x40, 0x0a, 0x10, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, + 0x28, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x43, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x6f, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, 0x21, 0x0a, + 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x32, 0x20, + 0x02, 0x28, 0x0c, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x3c, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x07, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x66, 0x0a, 0x19, 0x4c, 0x6f, + 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, + 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x49, 0x0a, 0x0e, 0x64, 0x69, 0x66, 0x66, 0x69, + 0x65, 0x5f, 0x68, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x44, 0x69, 0x66, + 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, + 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x64, 0x69, 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, + 0x61, 0x6e, 0x22, 0x88, 0x01, 0x0a, 0x21, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x44, 0x69, 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x43, + 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x73, 0x18, 0x0a, + 0x20, 0x02, 0x28, 0x0c, 0x52, 0x02, 0x67, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x14, 0x20, 0x02, 0x28, 0x05, 0x52, 0x12, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x67, 0x73, + 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x1e, 0x20, 0x02, 0x28, 0x0c, + 0x52, 0x0b, 0x67, 0x73, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x8f, 0x01, + 0x0a, 0x19, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x43, 0x68, 0x61, + 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x05, 0x67, + 0x72, 0x61, 0x69, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x46, 0x69, 0x6e, + 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x47, 0x72, 0x61, 0x69, 0x6e, 0x43, 0x68, 0x61, + 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x05, 0x67, 0x72, 0x61, 0x69, 0x6e, 0x12, 0x40, 0x0a, + 0x0b, 0x68, 0x6d, 0x61, 0x63, 0x5f, 0x72, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x18, 0x14, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, + 0x48, 0x6d, 0x61, 0x63, 0x52, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, + 0x6e, 0x67, 0x65, 0x52, 0x0a, 0x68, 0x6d, 0x61, 0x63, 0x52, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x22, + 0x2d, 0x0a, 0x19, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x47, 0x72, + 0x61, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x6b, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x6b, 0x22, 0x3e, + 0x0a, 0x1e, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x48, 0x6d, 0x61, + 0x63, 0x52, 0x69, 0x70, 0x65, 0x6d, 0x64, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x0a, 0x20, + 0x02, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x22, 0x47, + 0x0a, 0x11, 0x50, 0x6f, 0x57, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, + 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x09, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x63, 0x61, 0x73, 0x68, + 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x50, 0x6f, 0x57, 0x48, 0x61, 0x73, 0x68, + 0x43, 0x61, 0x73, 0x68, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x08, 0x68, + 0x61, 0x73, 0x68, 0x43, 0x61, 0x73, 0x68, 0x22, 0x5e, 0x0a, 0x14, 0x50, 0x6f, 0x57, 0x48, 0x61, + 0x73, 0x68, 0x43, 0x61, 0x73, 0x68, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, + 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0x8a, 0x01, 0x0a, 0x14, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, + 0x12, 0x31, 0x0a, 0x07, 0x73, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, + 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x07, 0x73, 0x68, 0x61, 0x6e, + 0x6e, 0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0d, 0x72, 0x63, 0x34, 0x5f, 0x73, 0x68, 0x61, 0x31, 0x5f, + 0x68, 0x6d, 0x61, 0x63, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x43, 0x72, 0x79, + 0x70, 0x74, 0x6f, 0x52, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, 0x48, 0x6d, 0x61, 0x63, 0x43, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x0b, 0x72, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, + 0x48, 0x6d, 0x61, 0x63, 0x22, 0x18, 0x0a, 0x16, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x53, 0x68, + 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x22, 0x1c, + 0x0a, 0x1a, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, 0x48, + 0x6d, 0x61, 0x63, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x22, 0x87, 0x01, 0x0a, + 0x16, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x75, 0x70, 0x67, 0x72, 0x61, + 0x64, 0x65, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x0a, + 0x20, 0x02, 0x28, 0x0c, 0x52, 0x11, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x53, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x73, 0x75, + 0x66, 0x66, 0x69, 0x78, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x68, 0x74, 0x74, 0x70, + 0x53, 0x75, 0x66, 0x66, 0x69, 0x78, 0x22, 0xa0, 0x01, 0x0a, 0x0d, 0x41, 0x50, 0x4c, 0x6f, 0x67, + 0x69, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x0a, 0x2e, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x43, + 0x6f, 0x64, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x64, 0x65, 0x6c, + 0x61, 0x79, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x44, + 0x65, 0x6c, 0x61, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x1e, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x2b, 0x0a, 0x11, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xdd, 0x01, 0x0a, 0x17, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x6c, 0x61, 0x69, + 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x4d, 0x0a, 0x15, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x5f, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x0a, + 0x20, 0x02, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, + 0x13, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x0c, 0x70, 0x6f, 0x77, 0x5f, 0x72, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x14, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x50, 0x6f, 0x57, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, + 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x1e, 0x20, + 0x02, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, 0x0a, 0x18, 0x4c, 0x6f, 0x67, + 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x48, 0x0a, 0x0e, 0x64, 0x69, 0x66, 0x66, 0x69, 0x65, 0x5f, + 0x68, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x44, 0x69, 0x66, 0x66, 0x69, + 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x0d, 0x64, 0x69, 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x22, + 0x36, 0x0a, 0x20, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x44, 0x69, + 0x66, 0x66, 0x69, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6d, 0x61, 0x63, 0x18, 0x0a, 0x20, 0x02, 0x28, + 0x0c, 0x52, 0x04, 0x68, 0x6d, 0x61, 0x63, 0x22, 0x45, 0x0a, 0x10, 0x50, 0x6f, 0x57, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x0a, 0x09, 0x68, + 0x61, 0x73, 0x68, 0x5f, 0x63, 0x61, 0x73, 0x68, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x50, 0x6f, 0x57, 0x48, 0x61, 0x73, 0x68, 0x43, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x08, 0x68, 0x61, 0x73, 0x68, 0x43, 0x61, 0x73, 0x68, 0x22, 0x36, + 0x0a, 0x13, 0x50, 0x6f, 0x57, 0x48, 0x61, 0x73, 0x68, 0x43, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x75, + 0x66, 0x66, 0x69, 0x78, 0x18, 0x0a, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x0a, 0x68, 0x61, 0x73, 0x68, + 0x53, 0x75, 0x66, 0x66, 0x69, 0x78, 0x22, 0x87, 0x01, 0x0a, 0x13, 0x43, 0x72, 0x79, 0x70, 0x74, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x30, + 0x0a, 0x07, 0x73, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x07, 0x73, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, + 0x12, 0x3e, 0x0a, 0x0d, 0x72, 0x63, 0x34, 0x5f, 0x73, 0x68, 0x61, 0x31, 0x5f, 0x68, 0x6d, 0x61, + 0x63, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, + 0x52, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, 0x48, 0x6d, 0x61, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x52, 0x0b, 0x72, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, 0x48, 0x6d, 0x61, 0x63, + 0x22, 0x2d, 0x0a, 0x15, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x75, 0x6d, + 0x6d, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x22, + 0x31, 0x0a, 0x19, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x63, 0x34, 0x53, 0x68, 0x61, 0x31, + 0x48, 0x6d, 0x61, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x64, 0x75, 0x6d, + 0x6d, 0x79, 0x2a, 0x7f, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x12, 0x12, 0x0a, + 0x0e, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x10, + 0x00, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x4c, 0x49, 0x42, + 0x53, 0x50, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, + 0x44, 0x55, 0x43, 0x54, 0x5f, 0x4d, 0x4f, 0x42, 0x49, 0x4c, 0x45, 0x10, 0x02, 0x12, 0x13, 0x0a, + 0x0f, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x50, 0x41, 0x52, 0x54, 0x4e, 0x45, 0x52, + 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x4c, 0x49, + 0x42, 0x53, 0x50, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x5f, 0x45, 0x4d, 0x42, 0x45, 0x44, 0x44, 0x45, + 0x44, 0x10, 0x05, 0x2a, 0x41, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x46, 0x6c, + 0x61, 0x67, 0x73, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x46, + 0x4c, 0x41, 0x47, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x52, + 0x4f, 0x44, 0x55, 0x43, 0x54, 0x5f, 0x46, 0x4c, 0x41, 0x47, 0x5f, 0x44, 0x45, 0x56, 0x5f, 0x42, + 0x55, 0x49, 0x4c, 0x44, 0x10, 0x01, 0x2a, 0xdc, 0x04, 0x0a, 0x08, 0x50, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, + 0x57, 0x49, 0x4e, 0x33, 0x32, 0x5f, 0x58, 0x38, 0x36, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x50, + 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4f, 0x53, 0x58, 0x5f, 0x58, 0x38, 0x36, 0x10, + 0x01, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x49, + 0x4e, 0x55, 0x58, 0x5f, 0x58, 0x38, 0x36, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x4c, 0x41, + 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x49, 0x50, 0x48, 0x4f, 0x4e, 0x45, 0x5f, 0x41, 0x52, 0x4d, + 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x53, + 0x36, 0x30, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x04, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x4c, 0x41, 0x54, + 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4f, 0x53, 0x58, 0x5f, 0x50, 0x50, 0x43, 0x10, 0x05, 0x12, 0x18, + 0x0a, 0x14, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x41, 0x4e, 0x44, 0x52, 0x4f, + 0x49, 0x44, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x06, 0x12, 0x1b, 0x0a, 0x17, 0x50, 0x4c, 0x41, 0x54, + 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x53, 0x5f, 0x43, 0x45, 0x5f, + 0x41, 0x52, 0x4d, 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, + 0x4d, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x58, 0x38, 0x36, 0x5f, 0x36, 0x34, 0x10, 0x08, + 0x12, 0x17, 0x0a, 0x13, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4f, 0x53, 0x58, + 0x5f, 0x58, 0x38, 0x36, 0x5f, 0x36, 0x34, 0x10, 0x09, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x4c, 0x41, + 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x50, 0x41, 0x4c, 0x4d, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x0a, + 0x12, 0x15, 0x0a, 0x11, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x49, 0x4e, + 0x55, 0x58, 0x5f, 0x53, 0x48, 0x10, 0x0b, 0x12, 0x18, 0x0a, 0x14, 0x50, 0x4c, 0x41, 0x54, 0x46, + 0x4f, 0x52, 0x4d, 0x5f, 0x46, 0x52, 0x45, 0x45, 0x42, 0x53, 0x44, 0x5f, 0x58, 0x38, 0x36, 0x10, + 0x0c, 0x12, 0x1b, 0x0a, 0x17, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x46, 0x52, + 0x45, 0x45, 0x42, 0x53, 0x44, 0x5f, 0x58, 0x38, 0x36, 0x5f, 0x36, 0x34, 0x10, 0x0d, 0x12, 0x1b, + 0x0a, 0x17, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x42, 0x4c, 0x41, 0x43, 0x4b, + 0x42, 0x45, 0x52, 0x52, 0x59, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x50, + 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x53, 0x4f, 0x4e, 0x4f, 0x53, 0x10, 0x0f, 0x12, + 0x17, 0x0a, 0x13, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x49, 0x4e, 0x55, + 0x58, 0x5f, 0x4d, 0x49, 0x50, 0x53, 0x10, 0x10, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x4c, 0x41, 0x54, + 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x11, + 0x12, 0x19, 0x0a, 0x15, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x4f, 0x47, + 0x49, 0x54, 0x45, 0x43, 0x48, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x12, 0x12, 0x1b, 0x0a, 0x17, 0x50, + 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x42, 0x4c, + 0x41, 0x43, 0x4b, 0x46, 0x49, 0x4e, 0x10, 0x13, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x4c, 0x41, 0x54, + 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x57, 0x50, 0x37, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x14, 0x12, 0x16, + 0x0a, 0x12, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x4f, 0x4e, 0x4b, 0x59, 0x4f, + 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x15, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, + 0x52, 0x4d, 0x5f, 0x51, 0x4e, 0x58, 0x4e, 0x54, 0x4f, 0x5f, 0x41, 0x52, 0x4d, 0x10, 0x16, 0x12, + 0x14, 0x0a, 0x10, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x5f, 0x42, 0x43, 0x4f, 0x5f, + 0x41, 0x52, 0x4d, 0x10, 0x17, 0x2a, 0x41, 0x0a, 0x0b, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, + 0x72, 0x69, 0x6e, 0x74, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x4e, 0x47, 0x45, 0x52, 0x50, 0x52, + 0x49, 0x4e, 0x54, 0x5f, 0x47, 0x52, 0x41, 0x49, 0x4e, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x46, + 0x49, 0x4e, 0x47, 0x45, 0x52, 0x50, 0x52, 0x49, 0x4e, 0x54, 0x5f, 0x48, 0x4d, 0x41, 0x43, 0x5f, + 0x52, 0x49, 0x50, 0x45, 0x4d, 0x44, 0x10, 0x01, 0x2a, 0x47, 0x0a, 0x0b, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x73, 0x75, 0x69, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x52, 0x59, 0x50, 0x54, + 0x4f, 0x5f, 0x53, 0x55, 0x49, 0x54, 0x45, 0x5f, 0x53, 0x48, 0x41, 0x4e, 0x4e, 0x4f, 0x4e, 0x10, + 0x00, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x52, 0x59, 0x50, 0x54, 0x4f, 0x5f, 0x53, 0x55, 0x49, 0x54, + 0x45, 0x5f, 0x52, 0x43, 0x34, 0x5f, 0x53, 0x48, 0x41, 0x31, 0x5f, 0x48, 0x4d, 0x41, 0x43, 0x10, + 0x01, 0x2a, 0x1e, 0x0a, 0x09, 0x50, 0x6f, 0x77, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x12, 0x11, + 0x0a, 0x0d, 0x50, 0x4f, 0x57, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x5f, 0x43, 0x41, 0x53, 0x48, 0x10, + 0x00, 0x2a, 0x89, 0x02, 0x0a, 0x09, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, + 0x11, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x72, 0x79, 0x41, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x41, 0x50, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x42, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x10, 0x05, 0x12, 0x15, 0x0a, 0x11, 0x54, 0x72, 0x61, + 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x09, + 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x72, 0x65, 0x6d, 0x69, 0x75, 0x6d, 0x41, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, + 0x42, 0x61, 0x64, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x10, 0x0c, + 0x12, 0x1f, 0x0a, 0x1b, 0x43, 0x6f, 0x75, 0x6c, 0x64, 0x4e, 0x6f, 0x74, 0x56, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x10, + 0x0d, 0x12, 0x11, 0x0a, 0x0d, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x69, 0x73, + 0x74, 0x73, 0x10, 0x0e, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x78, 0x74, 0x72, 0x61, 0x56, 0x65, 0x72, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x41, 0x70, + 0x70, 0x4b, 0x65, 0x79, 0x10, 0x10, 0x12, 0x15, 0x0a, 0x11, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x10, 0x11, 0x4a, 0xbd, 0x36, + 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xe2, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, + 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, 0x00, 0x0b, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x03, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x03, + 0x17, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x03, 0x24, 0x27, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x04, 0x04, 0x37, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x04, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x04, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x04, 0x19, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x04, 0x32, 0x36, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x05, + 0x04, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x05, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x05, 0x0d, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x05, 0x19, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x05, 0x32, 0x36, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x03, 0x06, 0x04, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x04, + 0x12, 0x03, 0x06, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x06, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x06, 0x17, + 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x06, 0x2e, 0x32, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x07, 0x04, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x04, 0x12, 0x03, 0x07, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x04, 0x06, 0x12, 0x03, 0x07, 0x0d, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x07, 0x23, 0x35, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x07, 0x38, 0x3c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x08, 0x04, + 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x04, 0x12, 0x03, 0x08, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x05, 0x12, 0x03, 0x08, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x08, 0x13, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x08, 0x22, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x06, 0x12, 0x03, 0x09, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x04, 0x12, + 0x03, 0x09, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x05, 0x12, 0x03, 0x09, + 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x09, 0x13, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x09, 0x1d, 0x21, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x0a, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x07, 0x04, 0x12, 0x03, 0x0a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x07, 0x06, 0x12, 0x03, 0x0a, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x01, + 0x12, 0x03, 0x0a, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x03, 0x12, 0x03, + 0x0a, 0x26, 0x2a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x0e, 0x00, 0x13, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x0f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x0f, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, + 0x15, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x1f, 0x22, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x10, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x10, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x10, 0x0d, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x10, 0x1a, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x10, 0x2a, 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x11, + 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x11, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x11, 0x0d, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x11, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x11, 0x21, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x03, 0x12, 0x03, 0x12, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, + 0x12, 0x03, 0x12, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, + 0x12, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x12, 0x14, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x12, 0x1e, 0x22, 0x0a, + 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x15, 0x00, 0x1b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, + 0x00, 0x01, 0x12, 0x03, 0x15, 0x05, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x16, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x16, + 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x16, 0x15, 0x18, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x17, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x17, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x17, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x18, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x18, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x18, + 0x15, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x19, 0x04, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x19, 0x04, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x19, 0x16, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x04, 0x12, 0x03, 0x1a, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x1a, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, + 0x03, 0x1a, 0x22, 0x25, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x04, 0x1d, 0x00, 0x20, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x1d, 0x05, 0x11, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1e, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x1e, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x00, 0x02, + 0x12, 0x03, 0x1e, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x01, 0x12, 0x03, 0x1f, + 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1f, 0x04, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, 0x03, 0x1f, 0x1d, 0x20, 0x0a, 0x0a, + 0x0a, 0x02, 0x05, 0x02, 0x12, 0x04, 0x22, 0x00, 0x3b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x02, + 0x01, 0x12, 0x03, 0x22, 0x05, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x00, 0x12, 0x03, + 0x23, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x23, 0x04, + 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x00, 0x02, 0x12, 0x03, 0x23, 0x19, 0x1c, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x24, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x24, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, + 0x02, 0x01, 0x02, 0x12, 0x03, 0x24, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x25, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x25, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x02, 0x12, 0x03, 0x25, 0x19, + 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x26, 0x04, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x26, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x02, 0x02, 0x03, 0x02, 0x12, 0x03, 0x26, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x27, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x27, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x04, 0x02, 0x12, 0x03, + 0x27, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x03, 0x28, 0x04, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x05, 0x01, 0x12, 0x03, 0x28, 0x04, 0x14, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x02, 0x02, 0x05, 0x02, 0x12, 0x03, 0x28, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x29, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x06, 0x01, 0x12, 0x03, 0x29, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x06, 0x02, + 0x12, 0x03, 0x29, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x07, 0x12, 0x03, 0x2a, + 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x07, 0x01, 0x12, 0x03, 0x2a, 0x04, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x07, 0x02, 0x12, 0x03, 0x2a, 0x1e, 0x21, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x02, 0x02, 0x08, 0x12, 0x03, 0x2b, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x02, 0x02, 0x08, 0x01, 0x12, 0x03, 0x2b, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x08, 0x02, 0x12, 0x03, 0x2b, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x09, 0x12, + 0x03, 0x2c, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x09, 0x01, 0x12, 0x03, 0x2c, + 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x09, 0x02, 0x12, 0x03, 0x2c, 0x1a, 0x1d, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x0a, 0x12, 0x03, 0x2d, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x02, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x2d, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x02, 0x02, 0x0a, 0x02, 0x12, 0x03, 0x2d, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, + 0x0b, 0x12, 0x03, 0x2e, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0b, 0x01, 0x12, + 0x03, 0x2e, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0b, 0x02, 0x12, 0x03, 0x2e, + 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x0c, 0x12, 0x03, 0x2f, 0x04, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x2f, 0x04, 0x18, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x02, 0x02, 0x0c, 0x02, 0x12, 0x03, 0x2f, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x02, 0x02, 0x0d, 0x12, 0x03, 0x30, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0d, + 0x01, 0x12, 0x03, 0x30, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0d, 0x02, 0x12, + 0x03, 0x30, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x0e, 0x12, 0x03, 0x31, 0x04, + 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x31, 0x04, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0e, 0x02, 0x12, 0x03, 0x31, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x02, 0x02, 0x0f, 0x12, 0x03, 0x32, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, + 0x02, 0x0f, 0x01, 0x12, 0x03, 0x32, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x0f, + 0x02, 0x12, 0x03, 0x32, 0x15, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x10, 0x12, 0x03, + 0x33, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x10, 0x01, 0x12, 0x03, 0x33, 0x04, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x10, 0x02, 0x12, 0x03, 0x33, 0x1a, 0x1e, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x11, 0x12, 0x03, 0x34, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x02, 0x02, 0x11, 0x01, 0x12, 0x03, 0x34, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, + 0x02, 0x11, 0x02, 0x12, 0x03, 0x34, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x12, + 0x12, 0x03, 0x35, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x12, 0x01, 0x12, 0x03, + 0x35, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x12, 0x02, 0x12, 0x03, 0x35, 0x1c, + 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x13, 0x12, 0x03, 0x36, 0x04, 0x23, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x02, 0x02, 0x13, 0x01, 0x12, 0x03, 0x36, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x02, 0x02, 0x13, 0x02, 0x12, 0x03, 0x36, 0x1e, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, + 0x02, 0x14, 0x12, 0x03, 0x37, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x14, 0x01, + 0x12, 0x03, 0x37, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x14, 0x02, 0x12, 0x03, + 0x37, 0x17, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x15, 0x12, 0x03, 0x38, 0x04, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x15, 0x01, 0x12, 0x03, 0x38, 0x04, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x02, 0x02, 0x15, 0x02, 0x12, 0x03, 0x38, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x02, 0x02, 0x16, 0x12, 0x03, 0x39, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x16, 0x01, 0x12, 0x03, 0x39, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x16, 0x02, + 0x12, 0x03, 0x39, 0x1a, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x17, 0x12, 0x03, 0x3a, + 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x17, 0x01, 0x12, 0x03, 0x3a, 0x04, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x17, 0x02, 0x12, 0x03, 0x3a, 0x17, 0x1b, 0x0a, 0x0a, + 0x0a, 0x02, 0x05, 0x03, 0x12, 0x04, 0x3d, 0x00, 0x40, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x03, + 0x01, 0x12, 0x03, 0x3d, 0x05, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x03, 0x02, 0x00, 0x12, 0x03, + 0x3e, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3e, 0x04, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, 0x02, 0x00, 0x02, 0x12, 0x03, 0x3e, 0x18, 0x1b, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x03, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3f, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x03, + 0x02, 0x01, 0x02, 0x12, 0x03, 0x3f, 0x1e, 0x21, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x04, 0x12, 0x04, + 0x42, 0x00, 0x45, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x04, 0x01, 0x12, 0x03, 0x42, 0x05, 0x10, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, 0x00, 0x12, 0x03, 0x43, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x43, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x04, 0x02, 0x00, 0x02, 0x12, 0x03, 0x43, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x44, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x44, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x04, 0x02, 0x01, 0x02, 0x12, 0x03, 0x44, + 0x21, 0x24, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x05, 0x12, 0x04, 0x47, 0x00, 0x49, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x05, 0x05, 0x01, 0x12, 0x03, 0x47, 0x05, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x05, + 0x02, 0x00, 0x12, 0x03, 0x48, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x05, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x48, 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x05, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x48, 0x14, 0x17, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x4c, 0x00, 0x4e, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x08, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x00, 0x12, 0x03, 0x4d, 0x04, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x4d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x4d, 0x0d, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4d, + 0x2b, 0x39, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4d, 0x3c, 0x3f, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x51, 0x00, 0x54, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x51, 0x08, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, + 0x12, 0x03, 0x52, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x52, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x52, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x52, 0x13, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x52, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x53, 0x04, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x53, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x53, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x53, 0x14, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x53, + 0x28, 0x2c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x57, 0x00, 0x5a, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x57, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, + 0x02, 0x00, 0x12, 0x03, 0x58, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x58, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x58, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x58, 0x12, + 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x58, 0x20, 0x23, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x59, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x04, 0x12, 0x03, 0x59, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x59, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x59, 0x12, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x59, 0x25, 0x28, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x5d, 0x00, 0x61, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x5d, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x5e, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x5e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x5e, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x5e, 0x19, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x5e, 0x25, + 0x28, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x5f, 0x04, 0x33, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x04, 0x12, 0x03, 0x5f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x5f, 0x0d, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x5f, 0x24, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x5f, 0x2e, 0x32, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, + 0x60, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x03, 0x60, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x60, 0x0d, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x60, 0x1b, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x60, 0x2a, 0x2e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x06, 0x12, 0x04, 0x63, 0x00, 0x6a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, + 0x63, 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x64, 0x04, 0x44, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x03, 0x64, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x64, 0x0d, 0x26, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x64, 0x27, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x64, 0x40, 0x43, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, + 0x12, 0x03, 0x65, 0x04, 0x44, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, 0x12, 0x03, + 0x65, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x65, 0x0d, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x65, 0x27, 0x3c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x65, 0x3f, 0x43, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, 0x66, 0x04, 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x02, 0x04, 0x12, 0x03, 0x66, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x66, 0x0d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x66, 0x1f, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x66, + 0x2f, 0x33, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x67, 0x04, 0x3a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x04, 0x12, 0x03, 0x67, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x06, 0x12, 0x03, 0x67, 0x0d, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x03, 0x01, 0x12, 0x03, 0x67, 0x22, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x67, 0x35, 0x39, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x04, 0x12, + 0x03, 0x68, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, 0x03, 0x68, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x05, 0x12, 0x03, 0x68, 0x0d, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x03, 0x68, 0x13, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x03, 0x68, 0x22, 0x26, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x05, 0x12, 0x03, 0x69, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x05, 0x04, 0x12, 0x03, 0x69, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x05, + 0x12, 0x03, 0x69, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x69, 0x13, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x03, 0x69, 0x1d, + 0x21, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x6c, 0x00, 0x6e, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x6c, 0x08, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, + 0x00, 0x12, 0x03, 0x6d, 0x04, 0x44, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x6d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x6d, + 0x0d, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6d, 0x2f, 0x3d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6d, 0x40, 0x43, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x70, 0x00, 0x74, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, + 0x01, 0x12, 0x03, 0x70, 0x08, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, + 0x71, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x71, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x71, 0x0d, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x71, 0x13, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x71, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x08, 0x02, 0x01, 0x12, 0x03, 0x72, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, + 0x04, 0x12, 0x03, 0x72, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x72, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x72, + 0x13, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x72, 0x2a, 0x2e, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x03, 0x73, 0x04, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x02, 0x04, 0x12, 0x03, 0x73, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x02, 0x05, 0x12, 0x03, 0x73, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x73, 0x13, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x73, 0x22, 0x26, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, 0x76, 0x00, 0x79, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x76, 0x08, 0x21, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x77, 0x04, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x77, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x77, 0x0d, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x77, 0x27, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x77, + 0x2f, 0x32, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x78, 0x04, 0x3f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12, 0x03, 0x78, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x03, 0x78, 0x0d, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x78, 0x2c, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x78, 0x3a, 0x3e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x7c, + 0x00, 0x7e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x7c, 0x08, 0x21, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x03, 0x7d, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, 0x03, 0x7d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x7d, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x7d, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x7d, 0x19, 0x1c, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0x81, 0x01, 0x00, 0x83, + 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0x81, 0x01, 0x08, 0x26, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0x82, 0x01, 0x04, 0x23, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, 0x04, 0x82, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, 0x82, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0x82, 0x01, 0x13, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x00, 0x03, 0x12, 0x04, 0x82, 0x01, 0x1f, 0x22, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0c, 0x12, + 0x06, 0x86, 0x01, 0x00, 0x88, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, + 0x86, 0x01, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0x87, 0x01, + 0x04, 0x32, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, 0x12, 0x04, 0x87, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0x87, 0x01, 0x0d, 0x21, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0x87, 0x01, 0x22, 0x2b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0x87, 0x01, 0x2e, 0x31, 0x0a, 0x0c, + 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0x8a, 0x01, 0x00, 0x8e, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x0d, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x08, 0x1c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, + 0x00, 0x12, 0x04, 0x8b, 0x01, 0x04, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, + 0x12, 0x04, 0x8b, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, + 0x04, 0x8b, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, + 0x8b, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8b, + 0x01, 0x1c, 0x1f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x04, + 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8c, 0x01, 0x0d, 0x12, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x13, 0x19, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8c, 0x01, 0x1c, 0x20, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0d, 0x02, 0x02, 0x12, 0x04, 0x8d, 0x01, 0x04, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x02, 0x04, 0x12, 0x04, 0x8d, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x02, 0x05, 0x12, 0x04, 0x8d, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, + 0x02, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, + 0x03, 0x12, 0x04, 0x8d, 0x01, 0x1c, 0x20, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0x91, + 0x01, 0x00, 0x94, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0x91, 0x01, + 0x08, 0x1c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x92, 0x01, 0x04, 0x32, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0x92, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x23, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0x92, 0x01, 0x24, 0x2b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0x92, 0x01, 0x2e, 0x31, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0x93, 0x01, 0x04, 0x3d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x01, 0x04, 0x12, 0x04, 0x93, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x01, 0x06, 0x12, 0x04, 0x93, 0x01, 0x0d, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, + 0x01, 0x12, 0x04, 0x93, 0x01, 0x28, 0x35, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, + 0x12, 0x04, 0x93, 0x01, 0x38, 0x3c, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, 0x97, 0x01, + 0x00, 0x98, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0x97, 0x01, 0x08, + 0x1e, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0x9b, 0x01, 0x00, 0x9c, 0x01, 0x01, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x08, 0x22, 0x0a, 0x0c, 0x0a, 0x02, + 0x04, 0x11, 0x12, 0x06, 0x9f, 0x01, 0x00, 0xa3, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, + 0x01, 0x12, 0x04, 0x9f, 0x01, 0x08, 0x1e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, + 0x04, 0xa0, 0x01, 0x04, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x04, 0x12, 0x04, + 0xa0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x05, 0x12, 0x04, 0xa0, + 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa0, 0x01, + 0x13, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa0, 0x01, 0x29, + 0x2c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x01, 0x12, 0x04, 0xa1, 0x01, 0x04, 0x24, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x04, 0x12, 0x04, 0xa1, 0x01, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x05, 0x12, 0x04, 0xa1, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x11, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa1, 0x01, 0x13, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x11, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa1, 0x01, 0x1f, 0x23, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x11, 0x02, 0x02, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, + 0x02, 0x04, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, + 0x05, 0x12, 0x04, 0xa2, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xa2, 0x01, 0x14, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xa2, 0x01, 0x22, 0x26, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x12, 0x12, 0x06, 0xa5, 0x01, 0x00, + 0xaa, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0xa5, 0x01, 0x08, 0x15, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, 0x04, 0xa6, 0x01, 0x04, 0x28, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x04, 0x12, 0x04, 0xa6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x00, 0x06, 0x12, 0x04, 0xa6, 0x01, 0x0d, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa6, 0x01, 0x17, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa6, 0x01, 0x24, 0x27, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x12, + 0x02, 0x01, 0x12, 0x04, 0xa7, 0x01, 0x04, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, + 0x04, 0x12, 0x04, 0xa7, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x05, + 0x12, 0x04, 0xa7, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xa7, 0x01, 0x13, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xa7, 0x01, 0x21, 0x25, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x02, 0x12, 0x04, 0xa8, 0x01, + 0x04, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x04, 0x12, 0x04, 0xa8, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x05, 0x12, 0x04, 0xa8, 0x01, 0x0d, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa8, 0x01, 0x13, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x03, 0x12, 0x04, 0xa8, 0x01, 0x1c, 0x20, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x12, 0x02, 0x03, 0x12, 0x04, 0xa9, 0x01, 0x04, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x03, 0x04, 0x12, 0x04, 0xa9, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x03, 0x05, 0x12, 0x04, 0xa9, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x03, 0x01, 0x12, 0x04, 0xa9, 0x01, 0x14, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x03, 0x03, 0x12, 0x04, 0xa9, 0x01, 0x28, 0x2c, 0x0a, 0x0c, 0x0a, 0x02, 0x05, 0x06, 0x12, 0x06, + 0xac, 0x01, 0x00, 0xb8, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x06, 0x01, 0x12, 0x04, 0xac, + 0x01, 0x05, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x00, 0x12, 0x04, 0xad, 0x01, 0x04, + 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x00, 0x01, 0x12, 0x04, 0xad, 0x01, 0x04, 0x11, + 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x00, 0x02, 0x12, 0x04, 0xad, 0x01, 0x14, 0x17, 0x0a, + 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x01, 0x12, 0x04, 0xae, 0x01, 0x04, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x05, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, 0xae, 0x01, 0x04, 0x10, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x06, 0x02, 0x01, 0x02, 0x12, 0x04, 0xae, 0x01, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x04, 0x05, + 0x06, 0x02, 0x02, 0x12, 0x04, 0xaf, 0x01, 0x04, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xaf, 0x01, 0x04, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x02, + 0x02, 0x12, 0x04, 0xaf, 0x01, 0x16, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x03, 0x12, + 0x04, 0xb0, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x03, 0x01, 0x12, 0x04, + 0xb0, 0x01, 0x04, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x03, 0x02, 0x12, 0x04, 0xb0, + 0x01, 0x18, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x04, 0x12, 0x04, 0xb1, 0x01, 0x04, + 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x04, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x04, 0x02, 0x12, 0x04, 0xb1, 0x01, 0x1d, 0x20, 0x0a, + 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x05, 0x12, 0x04, 0xb2, 0x01, 0x04, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x05, 0x06, 0x02, 0x05, 0x01, 0x12, 0x04, 0xb2, 0x01, 0x04, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x06, 0x02, 0x05, 0x02, 0x12, 0x04, 0xb2, 0x01, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x04, 0x05, + 0x06, 0x02, 0x06, 0x12, 0x04, 0xb3, 0x01, 0x04, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, + 0x06, 0x01, 0x12, 0x04, 0xb3, 0x01, 0x04, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x06, + 0x02, 0x12, 0x04, 0xb3, 0x01, 0x22, 0x25, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x07, 0x12, + 0x04, 0xb4, 0x01, 0x04, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x07, 0x01, 0x12, 0x04, + 0xb4, 0x01, 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x07, 0x02, 0x12, 0x04, 0xb4, + 0x01, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x08, 0x12, 0x04, 0xb5, 0x01, 0x04, + 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x08, 0x01, 0x12, 0x04, 0xb5, 0x01, 0x04, 0x1d, + 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x08, 0x02, 0x12, 0x04, 0xb5, 0x01, 0x20, 0x23, 0x0a, + 0x0c, 0x0a, 0x04, 0x05, 0x06, 0x02, 0x09, 0x12, 0x04, 0xb6, 0x01, 0x04, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x05, 0x06, 0x02, 0x09, 0x01, 0x12, 0x04, 0xb6, 0x01, 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x06, 0x02, 0x09, 0x02, 0x12, 0x04, 0xb6, 0x01, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x04, 0x05, + 0x06, 0x02, 0x0a, 0x12, 0x04, 0xb7, 0x01, 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, + 0x0a, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x04, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x06, 0x02, 0x0a, + 0x02, 0x12, 0x04, 0xb7, 0x01, 0x18, 0x1c, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x13, 0x12, 0x06, 0xba, + 0x01, 0x00, 0xbe, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xba, 0x01, + 0x08, 0x1f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xbb, 0x01, 0x04, 0x42, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbb, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x06, 0x12, 0x04, 0xbb, 0x01, 0x0d, 0x25, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbb, 0x01, 0x26, 0x3b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x00, 0x03, 0x12, 0x04, 0xbb, 0x01, 0x3e, 0x41, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x01, 0x12, 0x04, 0xbc, 0x01, 0x04, 0x32, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x01, 0x04, 0x12, 0x04, 0xbc, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x01, 0x06, 0x12, 0x04, 0xbc, 0x01, 0x0d, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, + 0x01, 0x12, 0x04, 0xbc, 0x01, 0x1e, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x03, + 0x12, 0x04, 0xbc, 0x01, 0x2d, 0x31, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x02, 0x12, 0x04, + 0xbd, 0x01, 0x04, 0x38, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x04, 0x12, 0x04, 0xbd, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x06, 0x12, 0x04, 0xbd, 0x01, + 0x0d, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x01, 0x21, + 0x30, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x03, 0x12, 0x04, 0xbd, 0x01, 0x33, 0x37, + 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x14, 0x12, 0x06, 0xc1, 0x01, 0x00, 0xc3, 0x01, 0x01, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0xc1, 0x01, 0x08, 0x20, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x14, 0x02, 0x00, 0x12, 0x04, 0xc2, 0x01, 0x04, 0x43, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, + 0x00, 0x04, 0x12, 0x04, 0xc2, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, + 0x06, 0x12, 0x04, 0xc2, 0x01, 0x0d, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xc2, 0x01, 0x2e, 0x3c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xc2, 0x01, 0x3f, 0x42, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x15, 0x12, 0x06, 0xc6, 0x01, 0x00, + 0xc8, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x15, 0x01, 0x12, 0x04, 0xc6, 0x01, 0x08, 0x28, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x00, 0x12, 0x04, 0xc7, 0x01, 0x04, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc7, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc7, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc7, 0x01, 0x13, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc7, 0x01, 0x1a, 0x1d, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x16, + 0x12, 0x06, 0xcb, 0x01, 0x00, 0xcd, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x16, 0x01, 0x12, + 0x04, 0xcb, 0x01, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x00, 0x12, 0x04, 0xcc, + 0x01, 0x04, 0x31, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x04, 0x12, 0x04, 0xcc, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x06, 0x12, 0x04, 0xcc, 0x01, 0x0d, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x01, 0x12, 0x04, 0xcc, 0x01, 0x21, 0x2a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x03, 0x12, 0x04, 0xcc, 0x01, 0x2d, 0x30, 0x0a, + 0x0c, 0x0a, 0x02, 0x04, 0x17, 0x12, 0x06, 0xd0, 0x01, 0x00, 0xd2, 0x01, 0x01, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x17, 0x01, 0x12, 0x04, 0xd0, 0x01, 0x08, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x17, + 0x02, 0x00, 0x12, 0x04, 0xd1, 0x01, 0x04, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, + 0x04, 0x12, 0x04, 0xd1, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x05, + 0x12, 0x04, 0xd1, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xd1, 0x01, 0x13, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xd1, 0x01, 0x21, 0x24, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x18, 0x12, 0x06, 0xd5, 0x01, 0x00, 0xd8, + 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x18, 0x01, 0x12, 0x04, 0xd5, 0x01, 0x08, 0x1b, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x18, 0x02, 0x00, 0x12, 0x04, 0xd6, 0x01, 0x04, 0x31, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x18, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x18, 0x02, 0x00, 0x06, 0x12, 0x04, 0xd6, 0x01, 0x0d, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x18, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd6, 0x01, 0x23, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, + 0x02, 0x00, 0x03, 0x12, 0x04, 0xd6, 0x01, 0x2d, 0x30, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x18, 0x02, + 0x01, 0x12, 0x04, 0xd7, 0x01, 0x04, 0x3c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x01, 0x04, + 0x12, 0x04, 0xd7, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x01, 0x06, 0x12, + 0x04, 0xd7, 0x01, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xd7, 0x01, 0x27, 0x34, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd7, + 0x01, 0x37, 0x3b, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x19, 0x12, 0x06, 0xdb, 0x01, 0x00, 0xdd, 0x01, + 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x19, 0x01, 0x12, 0x04, 0xdb, 0x01, 0x08, 0x1d, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x19, 0x02, 0x00, 0x12, 0x04, 0xdc, 0x01, 0x04, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x19, 0x02, 0x00, 0x04, 0x12, 0x04, 0xdc, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x19, 0x02, 0x00, 0x05, 0x12, 0x04, 0xdc, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x19, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xdc, 0x01, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x19, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xdc, 0x01, 0x1b, 0x1e, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x1a, 0x12, 0x06, + 0xe0, 0x01, 0x00, 0xe2, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x1a, 0x01, 0x12, 0x04, 0xe0, + 0x01, 0x08, 0x21, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x1a, 0x02, 0x00, 0x12, 0x04, 0xe1, 0x01, 0x04, + 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x00, 0x04, 0x12, 0x04, 0xe1, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe1, 0x01, 0x0d, 0x12, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe1, 0x01, 0x13, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe1, 0x01, 0x1b, 0x1e, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs index 46f89b59..ad9d9a32 100644 --- a/protocol/src/lib.rs +++ b/protocol/src/lib.rs @@ -1,8 +1,9 @@ -extern crate protobuf; +// Autogenerated by build.sh -include! (concat!(env!("OUT_DIR"), "/authentication.rs")); -include! (concat!(env!("OUT_DIR"), "/keyexchange.rs")); -include! (concat!(env!("OUT_DIR"), "/mercury.rs")); -include! (concat!(env!("OUT_DIR"), "/metadata.rs")); -include! (concat!(env!("OUT_DIR"), "/pubsub.rs")); -include! (concat!(env!("OUT_DIR"), "/spirc.rs")); +extern crate protobuf; +pub mod authentication; +pub mod keyexchange; +pub mod mercury; +pub mod metadata; +pub mod pubsub; +pub mod spirc; diff --git a/protocol/src/mercury.rs b/protocol/src/mercury.rs new file mode 100644 index 00000000..3e31fdce --- /dev/null +++ b/protocol/src/mercury.rs @@ -0,0 +1,2019 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct MercuryMultiGetRequest { + // message fields + request: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for MercuryMultiGetRequest {} + +impl MercuryMultiGetRequest { + pub fn new() -> MercuryMultiGetRequest { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static MercuryMultiGetRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MercuryMultiGetRequest, + }; + unsafe { + instance.get(|| { + MercuryMultiGetRequest { + request: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // repeated .MercuryRequest request = 1; + + pub fn clear_request(&mut self) { + self.request.clear(); + } + + // Param is passed by value, moved + pub fn set_request(&mut self, v: ::protobuf::RepeatedField) { + self.request = v; + } + + // Mutable pointer to the field. + pub fn mut_request(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.request + } + + // Take field + pub fn take_request(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.request, ::protobuf::RepeatedField::new()) + } + + pub fn get_request(&self) -> &[MercuryRequest] { + &self.request + } +} + +impl ::protobuf::Message for MercuryMultiGetRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.request)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.request { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.request { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for MercuryMultiGetRequest { + fn new() -> MercuryMultiGetRequest { + MercuryMultiGetRequest::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "request", + MercuryMultiGetRequest::get_request, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MercuryMultiGetRequest", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for MercuryMultiGetRequest { + fn clear(&mut self) { + self.clear_request(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for MercuryMultiGetRequest { + fn eq(&self, other: &MercuryMultiGetRequest) -> bool { + self.request == other.request && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for MercuryMultiGetRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct MercuryMultiGetReply { + // message fields + reply: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for MercuryMultiGetReply {} + +impl MercuryMultiGetReply { + pub fn new() -> MercuryMultiGetReply { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static MercuryMultiGetReply { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MercuryMultiGetReply, + }; + unsafe { + instance.get(|| { + MercuryMultiGetReply { + reply: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // repeated .MercuryReply reply = 1; + + pub fn clear_reply(&mut self) { + self.reply.clear(); + } + + // Param is passed by value, moved + pub fn set_reply(&mut self, v: ::protobuf::RepeatedField) { + self.reply = v; + } + + // Mutable pointer to the field. + pub fn mut_reply(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.reply + } + + // Take field + pub fn take_reply(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.reply, ::protobuf::RepeatedField::new()) + } + + pub fn get_reply(&self) -> &[MercuryReply] { + &self.reply + } +} + +impl ::protobuf::Message for MercuryMultiGetReply { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.reply)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.reply { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.reply { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for MercuryMultiGetReply { + fn new() -> MercuryMultiGetReply { + MercuryMultiGetReply::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "reply", + MercuryMultiGetReply::get_reply, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MercuryMultiGetReply", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for MercuryMultiGetReply { + fn clear(&mut self) { + self.clear_reply(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for MercuryMultiGetReply { + fn eq(&self, other: &MercuryMultiGetReply) -> bool { + self.reply == other.reply && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for MercuryMultiGetReply { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct MercuryRequest { + // message fields + uri: ::protobuf::SingularField<::std::string::String>, + content_type: ::protobuf::SingularField<::std::string::String>, + body: ::protobuf::SingularField<::std::vec::Vec>, + etag: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for MercuryRequest {} + +impl MercuryRequest { + pub fn new() -> MercuryRequest { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static MercuryRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MercuryRequest, + }; + unsafe { + instance.get(|| { + MercuryRequest { + uri: ::protobuf::SingularField::none(), + content_type: ::protobuf::SingularField::none(), + body: ::protobuf::SingularField::none(), + etag: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string uri = 1; + + pub fn clear_uri(&mut self) { + self.uri.clear(); + } + + pub fn has_uri(&self) -> bool { + self.uri.is_some() + } + + // Param is passed by value, moved + pub fn set_uri(&mut self, v: ::std::string::String) { + self.uri = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_uri(&mut self) -> &mut ::std::string::String { + if self.uri.is_none() { + self.uri.set_default(); + }; + self.uri.as_mut().unwrap() + } + + // Take field + pub fn take_uri(&mut self) -> ::std::string::String { + self.uri.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_uri(&self) -> &str { + match self.uri.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string content_type = 2; + + pub fn clear_content_type(&mut self) { + self.content_type.clear(); + } + + pub fn has_content_type(&self) -> bool { + self.content_type.is_some() + } + + // Param is passed by value, moved + pub fn set_content_type(&mut self, v: ::std::string::String) { + self.content_type = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_content_type(&mut self) -> &mut ::std::string::String { + if self.content_type.is_none() { + self.content_type.set_default(); + }; + self.content_type.as_mut().unwrap() + } + + // Take field + pub fn take_content_type(&mut self) -> ::std::string::String { + self.content_type.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_content_type(&self) -> &str { + match self.content_type.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bytes body = 3; + + pub fn clear_body(&mut self) { + self.body.clear(); + } + + pub fn has_body(&self) -> bool { + self.body.is_some() + } + + // Param is passed by value, moved + pub fn set_body(&mut self, v: ::std::vec::Vec) { + self.body = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_body(&mut self) -> &mut ::std::vec::Vec { + if self.body.is_none() { + self.body.set_default(); + }; + self.body.as_mut().unwrap() + } + + // Take field + pub fn take_body(&mut self) -> ::std::vec::Vec { + self.body.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_body(&self) -> &[u8] { + match self.body.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional bytes etag = 4; + + pub fn clear_etag(&mut self) { + self.etag.clear(); + } + + pub fn has_etag(&self) -> bool { + self.etag.is_some() + } + + // Param is passed by value, moved + pub fn set_etag(&mut self, v: ::std::vec::Vec) { + self.etag = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_etag(&mut self) -> &mut ::std::vec::Vec { + if self.etag.is_none() { + self.etag.set_default(); + }; + self.etag.as_mut().unwrap() + } + + // Take field + pub fn take_etag(&mut self) -> ::std::vec::Vec { + self.etag.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_etag(&self) -> &[u8] { + match self.etag.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for MercuryRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.content_type)); + }, + 3 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.body)); + }, + 4 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.etag)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.uri { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.content_type { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.body { + my_size += ::protobuf::rt::bytes_size(3, &value); + }; + for value in &self.etag { + my_size += ::protobuf::rt::bytes_size(4, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.uri.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.content_type.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.body.as_ref() { + try!(os.write_bytes(3, &v)); + }; + if let Some(v) = self.etag.as_ref() { + try!(os.write_bytes(4, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for MercuryRequest { + fn new() -> MercuryRequest { + MercuryRequest::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "uri", + MercuryRequest::has_uri, + MercuryRequest::get_uri, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "content_type", + MercuryRequest::has_content_type, + MercuryRequest::get_content_type, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "body", + MercuryRequest::has_body, + MercuryRequest::get_body, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "etag", + MercuryRequest::has_etag, + MercuryRequest::get_etag, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MercuryRequest", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for MercuryRequest { + fn clear(&mut self) { + self.clear_uri(); + self.clear_content_type(); + self.clear_body(); + self.clear_etag(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for MercuryRequest { + fn eq(&self, other: &MercuryRequest) -> bool { + self.uri == other.uri && + self.content_type == other.content_type && + self.body == other.body && + self.etag == other.etag && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for MercuryRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct MercuryReply { + // message fields + status_code: ::std::option::Option, + status_message: ::protobuf::SingularField<::std::string::String>, + cache_policy: ::std::option::Option, + ttl: ::std::option::Option, + etag: ::protobuf::SingularField<::std::vec::Vec>, + content_type: ::protobuf::SingularField<::std::string::String>, + body: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for MercuryReply {} + +impl MercuryReply { + pub fn new() -> MercuryReply { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static MercuryReply { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MercuryReply, + }; + unsafe { + instance.get(|| { + MercuryReply { + status_code: ::std::option::Option::None, + status_message: ::protobuf::SingularField::none(), + cache_policy: ::std::option::Option::None, + ttl: ::std::option::Option::None, + etag: ::protobuf::SingularField::none(), + content_type: ::protobuf::SingularField::none(), + body: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional sint32 status_code = 1; + + pub fn clear_status_code(&mut self) { + self.status_code = ::std::option::Option::None; + } + + pub fn has_status_code(&self) -> bool { + self.status_code.is_some() + } + + // Param is passed by value, moved + pub fn set_status_code(&mut self, v: i32) { + self.status_code = ::std::option::Option::Some(v); + } + + pub fn get_status_code(&self) -> i32 { + self.status_code.unwrap_or(0) + } + + // optional string status_message = 2; + + pub fn clear_status_message(&mut self) { + self.status_message.clear(); + } + + pub fn has_status_message(&self) -> bool { + self.status_message.is_some() + } + + // Param is passed by value, moved + pub fn set_status_message(&mut self, v: ::std::string::String) { + self.status_message = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_status_message(&mut self) -> &mut ::std::string::String { + if self.status_message.is_none() { + self.status_message.set_default(); + }; + self.status_message.as_mut().unwrap() + } + + // Take field + pub fn take_status_message(&mut self) -> ::std::string::String { + self.status_message.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_status_message(&self) -> &str { + match self.status_message.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional .MercuryReply.CachePolicy cache_policy = 3; + + pub fn clear_cache_policy(&mut self) { + self.cache_policy = ::std::option::Option::None; + } + + pub fn has_cache_policy(&self) -> bool { + self.cache_policy.is_some() + } + + // Param is passed by value, moved + pub fn set_cache_policy(&mut self, v: MercuryReply_CachePolicy) { + self.cache_policy = ::std::option::Option::Some(v); + } + + pub fn get_cache_policy(&self) -> MercuryReply_CachePolicy { + self.cache_policy.unwrap_or(MercuryReply_CachePolicy::CACHE_NO) + } + + // optional sint32 ttl = 4; + + pub fn clear_ttl(&mut self) { + self.ttl = ::std::option::Option::None; + } + + pub fn has_ttl(&self) -> bool { + self.ttl.is_some() + } + + // Param is passed by value, moved + pub fn set_ttl(&mut self, v: i32) { + self.ttl = ::std::option::Option::Some(v); + } + + pub fn get_ttl(&self) -> i32 { + self.ttl.unwrap_or(0) + } + + // optional bytes etag = 5; + + pub fn clear_etag(&mut self) { + self.etag.clear(); + } + + pub fn has_etag(&self) -> bool { + self.etag.is_some() + } + + // Param is passed by value, moved + pub fn set_etag(&mut self, v: ::std::vec::Vec) { + self.etag = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_etag(&mut self) -> &mut ::std::vec::Vec { + if self.etag.is_none() { + self.etag.set_default(); + }; + self.etag.as_mut().unwrap() + } + + // Take field + pub fn take_etag(&mut self) -> ::std::vec::Vec { + self.etag.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_etag(&self) -> &[u8] { + match self.etag.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string content_type = 6; + + pub fn clear_content_type(&mut self) { + self.content_type.clear(); + } + + pub fn has_content_type(&self) -> bool { + self.content_type.is_some() + } + + // Param is passed by value, moved + pub fn set_content_type(&mut self, v: ::std::string::String) { + self.content_type = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_content_type(&mut self) -> &mut ::std::string::String { + if self.content_type.is_none() { + self.content_type.set_default(); + }; + self.content_type.as_mut().unwrap() + } + + // Take field + pub fn take_content_type(&mut self) -> ::std::string::String { + self.content_type.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_content_type(&self) -> &str { + match self.content_type.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bytes body = 7; + + pub fn clear_body(&mut self) { + self.body.clear(); + } + + pub fn has_body(&self) -> bool { + self.body.is_some() + } + + // Param is passed by value, moved + pub fn set_body(&mut self, v: ::std::vec::Vec) { + self.body = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_body(&mut self) -> &mut ::std::vec::Vec { + if self.body.is_none() { + self.body.set_default(); + }; + self.body.as_mut().unwrap() + } + + // Take field + pub fn take_body(&mut self) -> ::std::vec::Vec { + self.body.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_body(&self) -> &[u8] { + match self.body.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for MercuryReply { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.status_code = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.status_message)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.cache_policy = ::std::option::Option::Some(tmp); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.ttl = ::std::option::Option::Some(tmp); + }, + 5 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.etag)); + }, + 6 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.content_type)); + }, + 7 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.body)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.status_code { + my_size += ::protobuf::rt::value_varint_zigzag_size(1, *value); + }; + for value in &self.status_message { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.cache_policy { + my_size += ::protobuf::rt::enum_size(3, *value); + }; + for value in &self.ttl { + my_size += ::protobuf::rt::value_varint_zigzag_size(4, *value); + }; + for value in &self.etag { + my_size += ::protobuf::rt::bytes_size(5, &value); + }; + for value in &self.content_type { + my_size += ::protobuf::rt::string_size(6, &value); + }; + for value in &self.body { + my_size += ::protobuf::rt::bytes_size(7, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.status_code { + try!(os.write_sint32(1, v)); + }; + if let Some(v) = self.status_message.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.cache_policy { + try!(os.write_enum(3, v.value())); + }; + if let Some(v) = self.ttl { + try!(os.write_sint32(4, v)); + }; + if let Some(v) = self.etag.as_ref() { + try!(os.write_bytes(5, &v)); + }; + if let Some(v) = self.content_type.as_ref() { + try!(os.write_string(6, &v)); + }; + if let Some(v) = self.body.as_ref() { + try!(os.write_bytes(7, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for MercuryReply { + fn new() -> MercuryReply { + MercuryReply::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "status_code", + MercuryReply::has_status_code, + MercuryReply::get_status_code, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "status_message", + MercuryReply::has_status_message, + MercuryReply::get_status_message, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "cache_policy", + MercuryReply::has_cache_policy, + MercuryReply::get_cache_policy, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "ttl", + MercuryReply::has_ttl, + MercuryReply::get_ttl, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "etag", + MercuryReply::has_etag, + MercuryReply::get_etag, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "content_type", + MercuryReply::has_content_type, + MercuryReply::get_content_type, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "body", + MercuryReply::has_body, + MercuryReply::get_body, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MercuryReply", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for MercuryReply { + fn clear(&mut self) { + self.clear_status_code(); + self.clear_status_message(); + self.clear_cache_policy(); + self.clear_ttl(); + self.clear_etag(); + self.clear_content_type(); + self.clear_body(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for MercuryReply { + fn eq(&self, other: &MercuryReply) -> bool { + self.status_code == other.status_code && + self.status_message == other.status_message && + self.cache_policy == other.cache_policy && + self.ttl == other.ttl && + self.etag == other.etag && + self.content_type == other.content_type && + self.body == other.body && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for MercuryReply { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum MercuryReply_CachePolicy { + CACHE_NO = 1, + CACHE_PRIVATE = 2, + CACHE_PUBLIC = 3, +} + +impl ::protobuf::ProtobufEnum for MercuryReply_CachePolicy { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(MercuryReply_CachePolicy::CACHE_NO), + 2 => ::std::option::Option::Some(MercuryReply_CachePolicy::CACHE_PRIVATE), + 3 => ::std::option::Option::Some(MercuryReply_CachePolicy::CACHE_PUBLIC), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [MercuryReply_CachePolicy] = &[ + MercuryReply_CachePolicy::CACHE_NO, + MercuryReply_CachePolicy::CACHE_PRIVATE, + MercuryReply_CachePolicy::CACHE_PUBLIC, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("MercuryReply_CachePolicy", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for MercuryReply_CachePolicy { +} + +#[derive(Clone,Default)] +pub struct Header { + // message fields + uri: ::protobuf::SingularField<::std::string::String>, + content_type: ::protobuf::SingularField<::std::string::String>, + method: ::protobuf::SingularField<::std::string::String>, + status_code: ::std::option::Option, + user_fields: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Header {} + +impl Header { + pub fn new() -> Header { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Header { + static mut instance: ::protobuf::lazy::Lazy
= ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Header, + }; + unsafe { + instance.get(|| { + Header { + uri: ::protobuf::SingularField::none(), + content_type: ::protobuf::SingularField::none(), + method: ::protobuf::SingularField::none(), + status_code: ::std::option::Option::None, + user_fields: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string uri = 1; + + pub fn clear_uri(&mut self) { + self.uri.clear(); + } + + pub fn has_uri(&self) -> bool { + self.uri.is_some() + } + + // Param is passed by value, moved + pub fn set_uri(&mut self, v: ::std::string::String) { + self.uri = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_uri(&mut self) -> &mut ::std::string::String { + if self.uri.is_none() { + self.uri.set_default(); + }; + self.uri.as_mut().unwrap() + } + + // Take field + pub fn take_uri(&mut self) -> ::std::string::String { + self.uri.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_uri(&self) -> &str { + match self.uri.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string content_type = 2; + + pub fn clear_content_type(&mut self) { + self.content_type.clear(); + } + + pub fn has_content_type(&self) -> bool { + self.content_type.is_some() + } + + // Param is passed by value, moved + pub fn set_content_type(&mut self, v: ::std::string::String) { + self.content_type = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_content_type(&mut self) -> &mut ::std::string::String { + if self.content_type.is_none() { + self.content_type.set_default(); + }; + self.content_type.as_mut().unwrap() + } + + // Take field + pub fn take_content_type(&mut self) -> ::std::string::String { + self.content_type.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_content_type(&self) -> &str { + match self.content_type.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string method = 3; + + pub fn clear_method(&mut self) { + self.method.clear(); + } + + pub fn has_method(&self) -> bool { + self.method.is_some() + } + + // Param is passed by value, moved + pub fn set_method(&mut self, v: ::std::string::String) { + self.method = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_method(&mut self) -> &mut ::std::string::String { + if self.method.is_none() { + self.method.set_default(); + }; + self.method.as_mut().unwrap() + } + + // Take field + pub fn take_method(&mut self) -> ::std::string::String { + self.method.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_method(&self) -> &str { + match self.method.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional sint32 status_code = 4; + + pub fn clear_status_code(&mut self) { + self.status_code = ::std::option::Option::None; + } + + pub fn has_status_code(&self) -> bool { + self.status_code.is_some() + } + + // Param is passed by value, moved + pub fn set_status_code(&mut self, v: i32) { + self.status_code = ::std::option::Option::Some(v); + } + + pub fn get_status_code(&self) -> i32 { + self.status_code.unwrap_or(0) + } + + // repeated .UserField user_fields = 6; + + pub fn clear_user_fields(&mut self) { + self.user_fields.clear(); + } + + // Param is passed by value, moved + pub fn set_user_fields(&mut self, v: ::protobuf::RepeatedField) { + self.user_fields = v; + } + + // Mutable pointer to the field. + pub fn mut_user_fields(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.user_fields + } + + // Take field + pub fn take_user_fields(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.user_fields, ::protobuf::RepeatedField::new()) + } + + pub fn get_user_fields(&self) -> &[UserField] { + &self.user_fields + } +} + +impl ::protobuf::Message for Header { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.content_type)); + }, + 3 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.method)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.status_code = ::std::option::Option::Some(tmp); + }, + 6 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.user_fields)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.uri { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.content_type { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.method { + my_size += ::protobuf::rt::string_size(3, &value); + }; + for value in &self.status_code { + my_size += ::protobuf::rt::value_varint_zigzag_size(4, *value); + }; + for value in &self.user_fields { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.uri.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.content_type.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.method.as_ref() { + try!(os.write_string(3, &v)); + }; + if let Some(v) = self.status_code { + try!(os.write_sint32(4, v)); + }; + for v in &self.user_fields { + try!(os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::
() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Header { + fn new() -> Header { + Header::new() + } + + fn descriptor_static(_: ::std::option::Option
) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "uri", + Header::has_uri, + Header::get_uri, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "content_type", + Header::has_content_type, + Header::get_content_type, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "method", + Header::has_method, + Header::get_method, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "status_code", + Header::has_status_code, + Header::get_status_code, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "user_fields", + Header::get_user_fields, + )); + ::protobuf::reflect::MessageDescriptor::new::
( + "Header", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Header { + fn clear(&mut self) { + self.clear_uri(); + self.clear_content_type(); + self.clear_method(); + self.clear_status_code(); + self.clear_user_fields(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Header { + fn eq(&self, other: &Header) -> bool { + self.uri == other.uri && + self.content_type == other.content_type && + self.method == other.method && + self.status_code == other.status_code && + self.user_fields == other.user_fields && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Header { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct UserField { + // message fields + key: ::protobuf::SingularField<::std::string::String>, + value: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for UserField {} + +impl UserField { + pub fn new() -> UserField { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static UserField { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UserField, + }; + unsafe { + instance.get(|| { + UserField { + key: ::protobuf::SingularField::none(), + value: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string key = 1; + + pub fn clear_key(&mut self) { + self.key.clear(); + } + + pub fn has_key(&self) -> bool { + self.key.is_some() + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::string::String) { + self.key = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::string::String { + if self.key.is_none() { + self.key.set_default(); + }; + self.key.as_mut().unwrap() + } + + // Take field + pub fn take_key(&mut self) -> ::std::string::String { + self.key.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_key(&self) -> &str { + match self.key.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bytes value = 2; + + pub fn clear_value(&mut self) { + self.value.clear(); + } + + pub fn has_value(&self) -> bool { + self.value.is_some() + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + if self.value.is_none() { + self.value.set_default(); + }; + self.value.as_mut().unwrap() + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + self.value.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_value(&self) -> &[u8] { + match self.value.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for UserField { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.key)); + }, + 2 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.value)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.key { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.value { + my_size += ::protobuf::rt::bytes_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.key.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.value.as_ref() { + try!(os.write_bytes(2, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for UserField { + fn new() -> UserField { + UserField::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "key", + UserField::has_key, + UserField::get_key, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "value", + UserField::has_value, + UserField::get_value, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UserField", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for UserField { + fn clear(&mut self) { + self.clear_key(); + self.clear_value(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for UserField { + fn eq(&self, other: &UserField) -> bool { + self.key == other.key && + self.value == other.value && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for UserField { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x0d, 0x6d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0x43, 0x0a, 0x16, 0x4d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x47, + 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x07, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x4d, 0x65, 0x72, + 0x63, 0x75, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0x3b, 0x0a, 0x14, 0x4d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x4d, + 0x75, 0x6c, 0x74, 0x69, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x23, 0x0a, 0x05, + 0x72, 0x65, 0x70, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x4d, 0x65, + 0x72, 0x63, 0x75, 0x72, 0x79, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x52, 0x05, 0x72, 0x65, 0x70, 0x6c, + 0x79, 0x22, 0x6d, 0x0a, 0x0e, 0x4d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x12, 0x0a, 0x04, + 0x65, 0x74, 0x61, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, + 0x22, 0xb3, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x52, 0x65, 0x70, 0x6c, + 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, + 0x64, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3c, 0x0a, 0x0c, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x19, 0x2e, 0x4d, 0x65, 0x72, 0x63, 0x75, 0x72, 0x79, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x2e, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x74, 0x6c, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x74, 0x74, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x74, 0x61, + 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x21, 0x0a, + 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x62, 0x6f, 0x64, 0x79, 0x22, 0x40, 0x0a, 0x0b, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4e, 0x4f, 0x10, + 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x52, 0x49, 0x56, 0x41, + 0x54, 0x45, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x0c, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x55, + 0x42, 0x4c, 0x49, 0x43, 0x10, 0x03, 0x22, 0xa3, 0x01, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x75, 0x72, 0x69, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1f, + 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x11, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, + 0x2b, 0x0a, 0x0b, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x52, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0x33, 0x0a, 0x09, + 0x55, 0x73, 0x65, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x4a, 0xaf, 0x0d, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x2c, 0x01, 0x0a, 0x08, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, 0x00, + 0x04, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, 0x1e, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x03, 0x0d, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x03, 0x1c, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x03, 0x26, 0x29, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x06, 0x00, 0x08, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x06, 0x08, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x07, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x07, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x07, 0x0d, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x07, + 0x1a, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x07, 0x22, 0x25, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x0a, 0x00, 0x0f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x0b, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x0b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0b, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x14, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0c, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x0c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x0c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x0c, 0x14, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0c, + 0x23, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0d, 0x04, 0x1e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, 0x03, 0x0d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0d, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0d, 0x13, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x0d, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x0e, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x12, 0x03, 0x0e, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x05, 0x12, 0x03, 0x0e, 0x0d, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x0e, 0x13, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, 0x03, 0x0e, 0x1a, 0x1d, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x03, 0x12, 0x04, 0x11, 0x00, 0x1e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, + 0x03, 0x11, 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x12, 0x04, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x12, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x12, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x12, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x12, 0x22, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x01, 0x12, 0x03, 0x13, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x04, 0x12, + 0x03, 0x13, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x13, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, 0x14, 0x22, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x13, 0x25, 0x28, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x14, 0x04, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x04, 0x12, 0x03, 0x14, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x14, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x14, 0x19, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x14, 0x28, 0x2b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x04, 0x00, 0x12, 0x04, 0x15, 0x04, 0x19, + 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x15, 0x09, 0x14, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x16, 0x08, 0x17, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x16, 0x08, 0x10, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x16, 0x13, 0x16, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x17, 0x08, 0x1c, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x17, 0x08, 0x15, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x17, 0x18, 0x1b, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x18, 0x08, 0x1b, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x18, 0x08, 0x14, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x18, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x1a, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x03, 0x04, 0x12, 0x03, 0x1a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, + 0x12, 0x03, 0x1a, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x1a, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1a, 0x1a, + 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x1b, 0x04, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x04, 0x12, 0x03, 0x1b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x04, 0x05, 0x12, 0x03, 0x1b, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x04, 0x01, 0x12, 0x03, 0x1b, 0x13, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x03, 0x12, 0x03, 0x1b, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, + 0x1c, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x04, 0x12, 0x03, 0x1c, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x03, 0x1c, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x1c, 0x14, 0x20, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1c, 0x23, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x06, 0x12, 0x03, 0x1d, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, + 0x04, 0x12, 0x03, 0x1d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x05, 0x12, + 0x03, 0x1d, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x01, 0x12, 0x03, 0x1d, + 0x13, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x03, 0x12, 0x03, 0x1d, 0x1a, 0x1d, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x21, 0x00, 0x27, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x04, 0x01, 0x12, 0x03, 0x21, 0x08, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, + 0x12, 0x03, 0x22, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x22, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x22, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x14, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x1a, 0x1e, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x23, 0x04, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x23, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x23, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x23, 0x14, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x23, + 0x23, 0x27, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x24, 0x04, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x24, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x24, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x24, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x24, 0x1d, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, + 0x03, 0x25, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, 0x03, 0x25, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x03, 0x25, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x25, 0x14, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x25, 0x22, 0x26, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x26, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x04, 0x04, 0x12, 0x03, 0x26, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x06, + 0x12, 0x03, 0x26, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x26, 0x17, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, 0x26, 0x25, + 0x29, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x29, 0x00, 0x2c, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x29, 0x08, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x2a, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x2a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2a, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2a, 0x14, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2a, 0x1a, 0x1e, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x2b, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x04, 0x12, 0x03, 0x2b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x2b, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x2b, 0x13, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2b, 0x1b, 0x1f, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/protocol/src/metadata.rs b/protocol/src/metadata.rs new file mode 100644 index 00000000..6d1faa2a --- /dev/null +++ b/protocol/src/metadata.rs @@ -0,0 +1,6817 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct TopTracks { + // message fields + country: ::protobuf::SingularField<::std::string::String>, + track: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for TopTracks {} + +impl TopTracks { + pub fn new() -> TopTracks { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static TopTracks { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TopTracks, + }; + unsafe { + instance.get(|| { + TopTracks { + country: ::protobuf::SingularField::none(), + track: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string country = 1; + + pub fn clear_country(&mut self) { + self.country.clear(); + } + + pub fn has_country(&self) -> bool { + self.country.is_some() + } + + // Param is passed by value, moved + pub fn set_country(&mut self, v: ::std::string::String) { + self.country = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_country(&mut self) -> &mut ::std::string::String { + if self.country.is_none() { + self.country.set_default(); + }; + self.country.as_mut().unwrap() + } + + // Take field + pub fn take_country(&mut self) -> ::std::string::String { + self.country.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_country(&self) -> &str { + match self.country.as_ref() { + Some(v) => &v, + None => "", + } + } + + // repeated .Track track = 2; + + pub fn clear_track(&mut self) { + self.track.clear(); + } + + // Param is passed by value, moved + pub fn set_track(&mut self, v: ::protobuf::RepeatedField) { + self.track = v; + } + + // Mutable pointer to the field. + pub fn mut_track(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.track + } + + // Take field + pub fn take_track(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.track, ::protobuf::RepeatedField::new()) + } + + pub fn get_track(&self) -> &[Track] { + &self.track + } +} + +impl ::protobuf::Message for TopTracks { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.country)); + }, + 2 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.track)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.country { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.track { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.country.as_ref() { + try!(os.write_string(1, &v)); + }; + for v in &self.track { + try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for TopTracks { + fn new() -> TopTracks { + TopTracks::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "country", + TopTracks::has_country, + TopTracks::get_country, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "track", + TopTracks::get_track, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TopTracks", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for TopTracks { + fn clear(&mut self) { + self.clear_country(); + self.clear_track(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for TopTracks { + fn eq(&self, other: &TopTracks) -> bool { + self.country == other.country && + self.track == other.track && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for TopTracks { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct ActivityPeriod { + // message fields + start_year: ::std::option::Option, + end_year: ::std::option::Option, + decade: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ActivityPeriod {} + +impl ActivityPeriod { + pub fn new() -> ActivityPeriod { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ActivityPeriod { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ActivityPeriod, + }; + unsafe { + instance.get(|| { + ActivityPeriod { + start_year: ::std::option::Option::None, + end_year: ::std::option::Option::None, + decade: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional sint32 start_year = 1; + + pub fn clear_start_year(&mut self) { + self.start_year = ::std::option::Option::None; + } + + pub fn has_start_year(&self) -> bool { + self.start_year.is_some() + } + + // Param is passed by value, moved + pub fn set_start_year(&mut self, v: i32) { + self.start_year = ::std::option::Option::Some(v); + } + + pub fn get_start_year(&self) -> i32 { + self.start_year.unwrap_or(0) + } + + // optional sint32 end_year = 2; + + pub fn clear_end_year(&mut self) { + self.end_year = ::std::option::Option::None; + } + + pub fn has_end_year(&self) -> bool { + self.end_year.is_some() + } + + // Param is passed by value, moved + pub fn set_end_year(&mut self, v: i32) { + self.end_year = ::std::option::Option::Some(v); + } + + pub fn get_end_year(&self) -> i32 { + self.end_year.unwrap_or(0) + } + + // optional sint32 decade = 3; + + pub fn clear_decade(&mut self) { + self.decade = ::std::option::Option::None; + } + + pub fn has_decade(&self) -> bool { + self.decade.is_some() + } + + // Param is passed by value, moved + pub fn set_decade(&mut self, v: i32) { + self.decade = ::std::option::Option::Some(v); + } + + pub fn get_decade(&self) -> i32 { + self.decade.unwrap_or(0) + } +} + +impl ::protobuf::Message for ActivityPeriod { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.start_year = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.end_year = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.decade = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.start_year { + my_size += ::protobuf::rt::value_varint_zigzag_size(1, *value); + }; + for value in &self.end_year { + my_size += ::protobuf::rt::value_varint_zigzag_size(2, *value); + }; + for value in &self.decade { + my_size += ::protobuf::rt::value_varint_zigzag_size(3, *value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.start_year { + try!(os.write_sint32(1, v)); + }; + if let Some(v) = self.end_year { + try!(os.write_sint32(2, v)); + }; + if let Some(v) = self.decade { + try!(os.write_sint32(3, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ActivityPeriod { + fn new() -> ActivityPeriod { + ActivityPeriod::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "start_year", + ActivityPeriod::has_start_year, + ActivityPeriod::get_start_year, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "end_year", + ActivityPeriod::has_end_year, + ActivityPeriod::get_end_year, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "decade", + ActivityPeriod::has_decade, + ActivityPeriod::get_decade, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ActivityPeriod", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ActivityPeriod { + fn clear(&mut self) { + self.clear_start_year(); + self.clear_end_year(); + self.clear_decade(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ActivityPeriod { + fn eq(&self, other: &ActivityPeriod) -> bool { + self.start_year == other.start_year && + self.end_year == other.end_year && + self.decade == other.decade && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ActivityPeriod { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Artist { + // message fields + gid: ::protobuf::SingularField<::std::vec::Vec>, + name: ::protobuf::SingularField<::std::string::String>, + popularity: ::std::option::Option, + top_track: ::protobuf::RepeatedField, + album_group: ::protobuf::RepeatedField, + single_group: ::protobuf::RepeatedField, + compilation_group: ::protobuf::RepeatedField, + appears_on_group: ::protobuf::RepeatedField, + genre: ::protobuf::RepeatedField<::std::string::String>, + external_id: ::protobuf::RepeatedField, + portrait: ::protobuf::RepeatedField, + biography: ::protobuf::RepeatedField, + activity_period: ::protobuf::RepeatedField, + restriction: ::protobuf::RepeatedField, + related: ::protobuf::RepeatedField, + is_portrait_album_cover: ::std::option::Option, + portrait_group: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Artist {} + +impl Artist { + pub fn new() -> Artist { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Artist { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Artist, + }; + unsafe { + instance.get(|| { + Artist { + gid: ::protobuf::SingularField::none(), + name: ::protobuf::SingularField::none(), + popularity: ::std::option::Option::None, + top_track: ::protobuf::RepeatedField::new(), + album_group: ::protobuf::RepeatedField::new(), + single_group: ::protobuf::RepeatedField::new(), + compilation_group: ::protobuf::RepeatedField::new(), + appears_on_group: ::protobuf::RepeatedField::new(), + genre: ::protobuf::RepeatedField::new(), + external_id: ::protobuf::RepeatedField::new(), + portrait: ::protobuf::RepeatedField::new(), + biography: ::protobuf::RepeatedField::new(), + activity_period: ::protobuf::RepeatedField::new(), + restriction: ::protobuf::RepeatedField::new(), + related: ::protobuf::RepeatedField::new(), + is_portrait_album_cover: ::std::option::Option::None, + portrait_group: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes gid = 1; + + pub fn clear_gid(&mut self) { + self.gid.clear(); + } + + pub fn has_gid(&self) -> bool { + self.gid.is_some() + } + + // Param is passed by value, moved + pub fn set_gid(&mut self, v: ::std::vec::Vec) { + self.gid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec { + if self.gid.is_none() { + self.gid.set_default(); + }; + self.gid.as_mut().unwrap() + } + + // Take field + pub fn take_gid(&mut self) -> ::std::vec::Vec { + self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gid(&self) -> &[u8] { + match self.gid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string name = 2; + + pub fn clear_name(&mut self) { + self.name.clear(); + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name.set_default(); + }; + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional sint32 popularity = 3; + + pub fn clear_popularity(&mut self) { + self.popularity = ::std::option::Option::None; + } + + pub fn has_popularity(&self) -> bool { + self.popularity.is_some() + } + + // Param is passed by value, moved + pub fn set_popularity(&mut self, v: i32) { + self.popularity = ::std::option::Option::Some(v); + } + + pub fn get_popularity(&self) -> i32 { + self.popularity.unwrap_or(0) + } + + // repeated .TopTracks top_track = 4; + + pub fn clear_top_track(&mut self) { + self.top_track.clear(); + } + + // Param is passed by value, moved + pub fn set_top_track(&mut self, v: ::protobuf::RepeatedField) { + self.top_track = v; + } + + // Mutable pointer to the field. + pub fn mut_top_track(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.top_track + } + + // Take field + pub fn take_top_track(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.top_track, ::protobuf::RepeatedField::new()) + } + + pub fn get_top_track(&self) -> &[TopTracks] { + &self.top_track + } + + // repeated .AlbumGroup album_group = 5; + + pub fn clear_album_group(&mut self) { + self.album_group.clear(); + } + + // Param is passed by value, moved + pub fn set_album_group(&mut self, v: ::protobuf::RepeatedField) { + self.album_group = v; + } + + // Mutable pointer to the field. + pub fn mut_album_group(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.album_group + } + + // Take field + pub fn take_album_group(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.album_group, ::protobuf::RepeatedField::new()) + } + + pub fn get_album_group(&self) -> &[AlbumGroup] { + &self.album_group + } + + // repeated .AlbumGroup single_group = 6; + + pub fn clear_single_group(&mut self) { + self.single_group.clear(); + } + + // Param is passed by value, moved + pub fn set_single_group(&mut self, v: ::protobuf::RepeatedField) { + self.single_group = v; + } + + // Mutable pointer to the field. + pub fn mut_single_group(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.single_group + } + + // Take field + pub fn take_single_group(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.single_group, ::protobuf::RepeatedField::new()) + } + + pub fn get_single_group(&self) -> &[AlbumGroup] { + &self.single_group + } + + // repeated .AlbumGroup compilation_group = 7; + + pub fn clear_compilation_group(&mut self) { + self.compilation_group.clear(); + } + + // Param is passed by value, moved + pub fn set_compilation_group(&mut self, v: ::protobuf::RepeatedField) { + self.compilation_group = v; + } + + // Mutable pointer to the field. + pub fn mut_compilation_group(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.compilation_group + } + + // Take field + pub fn take_compilation_group(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.compilation_group, ::protobuf::RepeatedField::new()) + } + + pub fn get_compilation_group(&self) -> &[AlbumGroup] { + &self.compilation_group + } + + // repeated .AlbumGroup appears_on_group = 8; + + pub fn clear_appears_on_group(&mut self) { + self.appears_on_group.clear(); + } + + // Param is passed by value, moved + pub fn set_appears_on_group(&mut self, v: ::protobuf::RepeatedField) { + self.appears_on_group = v; + } + + // Mutable pointer to the field. + pub fn mut_appears_on_group(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.appears_on_group + } + + // Take field + pub fn take_appears_on_group(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.appears_on_group, ::protobuf::RepeatedField::new()) + } + + pub fn get_appears_on_group(&self) -> &[AlbumGroup] { + &self.appears_on_group + } + + // repeated string genre = 9; + + pub fn clear_genre(&mut self) { + self.genre.clear(); + } + + // Param is passed by value, moved + pub fn set_genre(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.genre = v; + } + + // Mutable pointer to the field. + pub fn mut_genre(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.genre + } + + // Take field + pub fn take_genre(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.genre, ::protobuf::RepeatedField::new()) + } + + pub fn get_genre(&self) -> &[::std::string::String] { + &self.genre + } + + // repeated .ExternalId external_id = 10; + + pub fn clear_external_id(&mut self) { + self.external_id.clear(); + } + + // Param is passed by value, moved + pub fn set_external_id(&mut self, v: ::protobuf::RepeatedField) { + self.external_id = v; + } + + // Mutable pointer to the field. + pub fn mut_external_id(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.external_id + } + + // Take field + pub fn take_external_id(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.external_id, ::protobuf::RepeatedField::new()) + } + + pub fn get_external_id(&self) -> &[ExternalId] { + &self.external_id + } + + // repeated .Image portrait = 11; + + pub fn clear_portrait(&mut self) { + self.portrait.clear(); + } + + // Param is passed by value, moved + pub fn set_portrait(&mut self, v: ::protobuf::RepeatedField) { + self.portrait = v; + } + + // Mutable pointer to the field. + pub fn mut_portrait(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.portrait + } + + // Take field + pub fn take_portrait(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.portrait, ::protobuf::RepeatedField::new()) + } + + pub fn get_portrait(&self) -> &[Image] { + &self.portrait + } + + // repeated .Biography biography = 12; + + pub fn clear_biography(&mut self) { + self.biography.clear(); + } + + // Param is passed by value, moved + pub fn set_biography(&mut self, v: ::protobuf::RepeatedField) { + self.biography = v; + } + + // Mutable pointer to the field. + pub fn mut_biography(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.biography + } + + // Take field + pub fn take_biography(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.biography, ::protobuf::RepeatedField::new()) + } + + pub fn get_biography(&self) -> &[Biography] { + &self.biography + } + + // repeated .ActivityPeriod activity_period = 13; + + pub fn clear_activity_period(&mut self) { + self.activity_period.clear(); + } + + // Param is passed by value, moved + pub fn set_activity_period(&mut self, v: ::protobuf::RepeatedField) { + self.activity_period = v; + } + + // Mutable pointer to the field. + pub fn mut_activity_period(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.activity_period + } + + // Take field + pub fn take_activity_period(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.activity_period, ::protobuf::RepeatedField::new()) + } + + pub fn get_activity_period(&self) -> &[ActivityPeriod] { + &self.activity_period + } + + // repeated .Restriction restriction = 14; + + pub fn clear_restriction(&mut self) { + self.restriction.clear(); + } + + // Param is passed by value, moved + pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField) { + self.restriction = v; + } + + // Mutable pointer to the field. + pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.restriction + } + + // Take field + pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new()) + } + + pub fn get_restriction(&self) -> &[Restriction] { + &self.restriction + } + + // repeated .Artist related = 15; + + pub fn clear_related(&mut self) { + self.related.clear(); + } + + // Param is passed by value, moved + pub fn set_related(&mut self, v: ::protobuf::RepeatedField) { + self.related = v; + } + + // Mutable pointer to the field. + pub fn mut_related(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.related + } + + // Take field + pub fn take_related(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.related, ::protobuf::RepeatedField::new()) + } + + pub fn get_related(&self) -> &[Artist] { + &self.related + } + + // optional bool is_portrait_album_cover = 16; + + pub fn clear_is_portrait_album_cover(&mut self) { + self.is_portrait_album_cover = ::std::option::Option::None; + } + + pub fn has_is_portrait_album_cover(&self) -> bool { + self.is_portrait_album_cover.is_some() + } + + // Param is passed by value, moved + pub fn set_is_portrait_album_cover(&mut self, v: bool) { + self.is_portrait_album_cover = ::std::option::Option::Some(v); + } + + pub fn get_is_portrait_album_cover(&self) -> bool { + self.is_portrait_album_cover.unwrap_or(false) + } + + // optional .ImageGroup portrait_group = 17; + + pub fn clear_portrait_group(&mut self) { + self.portrait_group.clear(); + } + + pub fn has_portrait_group(&self) -> bool { + self.portrait_group.is_some() + } + + // Param is passed by value, moved + pub fn set_portrait_group(&mut self, v: ImageGroup) { + self.portrait_group = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_portrait_group(&mut self) -> &mut ImageGroup { + if self.portrait_group.is_none() { + self.portrait_group.set_default(); + }; + self.portrait_group.as_mut().unwrap() + } + + // Take field + pub fn take_portrait_group(&mut self) -> ImageGroup { + self.portrait_group.take().unwrap_or_else(|| ImageGroup::new()) + } + + pub fn get_portrait_group(&self) -> &ImageGroup { + self.portrait_group.as_ref().unwrap_or_else(|| ImageGroup::default_instance()) + } +} + +impl ::protobuf::Message for Artist { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.popularity = ::std::option::Option::Some(tmp); + }, + 4 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.top_track)); + }, + 5 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.album_group)); + }, + 6 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.single_group)); + }, + 7 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.compilation_group)); + }, + 8 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.appears_on_group)); + }, + 9 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.genre)); + }, + 10 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.external_id)); + }, + 11 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.portrait)); + }, + 12 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.biography)); + }, + 13 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.activity_period)); + }, + 14 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)); + }, + 15 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.related)); + }, + 16 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.is_portrait_album_cover = ::std::option::Option::Some(tmp); + }, + 17 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.portrait_group)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gid { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.name { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.popularity { + my_size += ::protobuf::rt::value_varint_zigzag_size(3, *value); + }; + for value in &self.top_track { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.album_group { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.single_group { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.compilation_group { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.appears_on_group { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.genre { + my_size += ::protobuf::rt::string_size(9, &value); + }; + for value in &self.external_id { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.portrait { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.biography { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.activity_period { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.restriction { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.related { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.is_portrait_album_cover.is_some() { + my_size += 3; + }; + for value in &self.portrait_group { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gid.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.name.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.popularity { + try!(os.write_sint32(3, v)); + }; + for v in &self.top_track { + try!(os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.album_group { + try!(os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.single_group { + try!(os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.compilation_group { + try!(os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.appears_on_group { + try!(os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.genre { + try!(os.write_string(9, &v)); + }; + for v in &self.external_id { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.portrait { + try!(os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.biography { + try!(os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.activity_period { + try!(os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.restriction { + try!(os.write_tag(14, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.related { + try!(os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.is_portrait_album_cover { + try!(os.write_bool(16, v)); + }; + if let Some(v) = self.portrait_group.as_ref() { + try!(os.write_tag(17, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Artist { + fn new() -> Artist { + Artist::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gid", + Artist::has_gid, + Artist::get_gid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "name", + Artist::has_name, + Artist::get_name, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "popularity", + Artist::has_popularity, + Artist::get_popularity, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "top_track", + Artist::get_top_track, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "album_group", + Artist::get_album_group, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "single_group", + Artist::get_single_group, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "compilation_group", + Artist::get_compilation_group, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "appears_on_group", + Artist::get_appears_on_group, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "genre", + Artist::get_genre, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "external_id", + Artist::get_external_id, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "portrait", + Artist::get_portrait, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "biography", + Artist::get_biography, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "activity_period", + Artist::get_activity_period, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "restriction", + Artist::get_restriction, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "related", + Artist::get_related, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "is_portrait_album_cover", + Artist::has_is_portrait_album_cover, + Artist::get_is_portrait_album_cover, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "portrait_group", + Artist::has_portrait_group, + Artist::get_portrait_group, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Artist", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Artist { + fn clear(&mut self) { + self.clear_gid(); + self.clear_name(); + self.clear_popularity(); + self.clear_top_track(); + self.clear_album_group(); + self.clear_single_group(); + self.clear_compilation_group(); + self.clear_appears_on_group(); + self.clear_genre(); + self.clear_external_id(); + self.clear_portrait(); + self.clear_biography(); + self.clear_activity_period(); + self.clear_restriction(); + self.clear_related(); + self.clear_is_portrait_album_cover(); + self.clear_portrait_group(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Artist { + fn eq(&self, other: &Artist) -> bool { + self.gid == other.gid && + self.name == other.name && + self.popularity == other.popularity && + self.top_track == other.top_track && + self.album_group == other.album_group && + self.single_group == other.single_group && + self.compilation_group == other.compilation_group && + self.appears_on_group == other.appears_on_group && + self.genre == other.genre && + self.external_id == other.external_id && + self.portrait == other.portrait && + self.biography == other.biography && + self.activity_period == other.activity_period && + self.restriction == other.restriction && + self.related == other.related && + self.is_portrait_album_cover == other.is_portrait_album_cover && + self.portrait_group == other.portrait_group && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Artist { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct AlbumGroup { + // message fields + album: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for AlbumGroup {} + +impl AlbumGroup { + pub fn new() -> AlbumGroup { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static AlbumGroup { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AlbumGroup, + }; + unsafe { + instance.get(|| { + AlbumGroup { + album: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // repeated .Album album = 1; + + pub fn clear_album(&mut self) { + self.album.clear(); + } + + // Param is passed by value, moved + pub fn set_album(&mut self, v: ::protobuf::RepeatedField) { + self.album = v; + } + + // Mutable pointer to the field. + pub fn mut_album(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.album + } + + // Take field + pub fn take_album(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.album, ::protobuf::RepeatedField::new()) + } + + pub fn get_album(&self) -> &[Album] { + &self.album + } +} + +impl ::protobuf::Message for AlbumGroup { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.album)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.album { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.album { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for AlbumGroup { + fn new() -> AlbumGroup { + AlbumGroup::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "album", + AlbumGroup::get_album, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AlbumGroup", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for AlbumGroup { + fn clear(&mut self) { + self.clear_album(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for AlbumGroup { + fn eq(&self, other: &AlbumGroup) -> bool { + self.album == other.album && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for AlbumGroup { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Date { + // message fields + year: ::std::option::Option, + month: ::std::option::Option, + day: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Date {} + +impl Date { + pub fn new() -> Date { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Date { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Date, + }; + unsafe { + instance.get(|| { + Date { + year: ::std::option::Option::None, + month: ::std::option::Option::None, + day: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional sint32 year = 1; + + pub fn clear_year(&mut self) { + self.year = ::std::option::Option::None; + } + + pub fn has_year(&self) -> bool { + self.year.is_some() + } + + // Param is passed by value, moved + pub fn set_year(&mut self, v: i32) { + self.year = ::std::option::Option::Some(v); + } + + pub fn get_year(&self) -> i32 { + self.year.unwrap_or(0) + } + + // optional sint32 month = 2; + + pub fn clear_month(&mut self) { + self.month = ::std::option::Option::None; + } + + pub fn has_month(&self) -> bool { + self.month.is_some() + } + + // Param is passed by value, moved + pub fn set_month(&mut self, v: i32) { + self.month = ::std::option::Option::Some(v); + } + + pub fn get_month(&self) -> i32 { + self.month.unwrap_or(0) + } + + // optional sint32 day = 3; + + pub fn clear_day(&mut self) { + self.day = ::std::option::Option::None; + } + + pub fn has_day(&self) -> bool { + self.day.is_some() + } + + // Param is passed by value, moved + pub fn set_day(&mut self, v: i32) { + self.day = ::std::option::Option::Some(v); + } + + pub fn get_day(&self) -> i32 { + self.day.unwrap_or(0) + } +} + +impl ::protobuf::Message for Date { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.year = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.month = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.day = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.year { + my_size += ::protobuf::rt::value_varint_zigzag_size(1, *value); + }; + for value in &self.month { + my_size += ::protobuf::rt::value_varint_zigzag_size(2, *value); + }; + for value in &self.day { + my_size += ::protobuf::rt::value_varint_zigzag_size(3, *value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.year { + try!(os.write_sint32(1, v)); + }; + if let Some(v) = self.month { + try!(os.write_sint32(2, v)); + }; + if let Some(v) = self.day { + try!(os.write_sint32(3, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Date { + fn new() -> Date { + Date::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "year", + Date::has_year, + Date::get_year, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "month", + Date::has_month, + Date::get_month, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "day", + Date::has_day, + Date::get_day, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Date", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Date { + fn clear(&mut self) { + self.clear_year(); + self.clear_month(); + self.clear_day(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Date { + fn eq(&self, other: &Date) -> bool { + self.year == other.year && + self.month == other.month && + self.day == other.day && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Date { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Album { + // message fields + gid: ::protobuf::SingularField<::std::vec::Vec>, + name: ::protobuf::SingularField<::std::string::String>, + artist: ::protobuf::RepeatedField, + typ: ::std::option::Option, + label: ::protobuf::SingularField<::std::string::String>, + date: ::protobuf::SingularPtrField, + popularity: ::std::option::Option, + genre: ::protobuf::RepeatedField<::std::string::String>, + cover: ::protobuf::RepeatedField, + external_id: ::protobuf::RepeatedField, + disc: ::protobuf::RepeatedField, + review: ::protobuf::RepeatedField<::std::string::String>, + copyright: ::protobuf::RepeatedField, + restriction: ::protobuf::RepeatedField, + related: ::protobuf::RepeatedField, + sale_period: ::protobuf::RepeatedField, + cover_group: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Album {} + +impl Album { + pub fn new() -> Album { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Album { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Album, + }; + unsafe { + instance.get(|| { + Album { + gid: ::protobuf::SingularField::none(), + name: ::protobuf::SingularField::none(), + artist: ::protobuf::RepeatedField::new(), + typ: ::std::option::Option::None, + label: ::protobuf::SingularField::none(), + date: ::protobuf::SingularPtrField::none(), + popularity: ::std::option::Option::None, + genre: ::protobuf::RepeatedField::new(), + cover: ::protobuf::RepeatedField::new(), + external_id: ::protobuf::RepeatedField::new(), + disc: ::protobuf::RepeatedField::new(), + review: ::protobuf::RepeatedField::new(), + copyright: ::protobuf::RepeatedField::new(), + restriction: ::protobuf::RepeatedField::new(), + related: ::protobuf::RepeatedField::new(), + sale_period: ::protobuf::RepeatedField::new(), + cover_group: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes gid = 1; + + pub fn clear_gid(&mut self) { + self.gid.clear(); + } + + pub fn has_gid(&self) -> bool { + self.gid.is_some() + } + + // Param is passed by value, moved + pub fn set_gid(&mut self, v: ::std::vec::Vec) { + self.gid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec { + if self.gid.is_none() { + self.gid.set_default(); + }; + self.gid.as_mut().unwrap() + } + + // Take field + pub fn take_gid(&mut self) -> ::std::vec::Vec { + self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gid(&self) -> &[u8] { + match self.gid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string name = 2; + + pub fn clear_name(&mut self) { + self.name.clear(); + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name.set_default(); + }; + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + + // repeated .Artist artist = 3; + + pub fn clear_artist(&mut self) { + self.artist.clear(); + } + + // Param is passed by value, moved + pub fn set_artist(&mut self, v: ::protobuf::RepeatedField) { + self.artist = v; + } + + // Mutable pointer to the field. + pub fn mut_artist(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.artist + } + + // Take field + pub fn take_artist(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.artist, ::protobuf::RepeatedField::new()) + } + + pub fn get_artist(&self) -> &[Artist] { + &self.artist + } + + // optional .Album.Type typ = 4; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: Album_Type) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> Album_Type { + self.typ.unwrap_or(Album_Type::ALBUM) + } + + // optional string label = 5; + + pub fn clear_label(&mut self) { + self.label.clear(); + } + + pub fn has_label(&self) -> bool { + self.label.is_some() + } + + // Param is passed by value, moved + pub fn set_label(&mut self, v: ::std::string::String) { + self.label = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_label(&mut self) -> &mut ::std::string::String { + if self.label.is_none() { + self.label.set_default(); + }; + self.label.as_mut().unwrap() + } + + // Take field + pub fn take_label(&mut self) -> ::std::string::String { + self.label.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_label(&self) -> &str { + match self.label.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional .Date date = 6; + + pub fn clear_date(&mut self) { + self.date.clear(); + } + + pub fn has_date(&self) -> bool { + self.date.is_some() + } + + // Param is passed by value, moved + pub fn set_date(&mut self, v: Date) { + self.date = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_date(&mut self) -> &mut Date { + if self.date.is_none() { + self.date.set_default(); + }; + self.date.as_mut().unwrap() + } + + // Take field + pub fn take_date(&mut self) -> Date { + self.date.take().unwrap_or_else(|| Date::new()) + } + + pub fn get_date(&self) -> &Date { + self.date.as_ref().unwrap_or_else(|| Date::default_instance()) + } + + // optional sint32 popularity = 7; + + pub fn clear_popularity(&mut self) { + self.popularity = ::std::option::Option::None; + } + + pub fn has_popularity(&self) -> bool { + self.popularity.is_some() + } + + // Param is passed by value, moved + pub fn set_popularity(&mut self, v: i32) { + self.popularity = ::std::option::Option::Some(v); + } + + pub fn get_popularity(&self) -> i32 { + self.popularity.unwrap_or(0) + } + + // repeated string genre = 8; + + pub fn clear_genre(&mut self) { + self.genre.clear(); + } + + // Param is passed by value, moved + pub fn set_genre(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.genre = v; + } + + // Mutable pointer to the field. + pub fn mut_genre(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.genre + } + + // Take field + pub fn take_genre(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.genre, ::protobuf::RepeatedField::new()) + } + + pub fn get_genre(&self) -> &[::std::string::String] { + &self.genre + } + + // repeated .Image cover = 9; + + pub fn clear_cover(&mut self) { + self.cover.clear(); + } + + // Param is passed by value, moved + pub fn set_cover(&mut self, v: ::protobuf::RepeatedField) { + self.cover = v; + } + + // Mutable pointer to the field. + pub fn mut_cover(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.cover + } + + // Take field + pub fn take_cover(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.cover, ::protobuf::RepeatedField::new()) + } + + pub fn get_cover(&self) -> &[Image] { + &self.cover + } + + // repeated .ExternalId external_id = 10; + + pub fn clear_external_id(&mut self) { + self.external_id.clear(); + } + + // Param is passed by value, moved + pub fn set_external_id(&mut self, v: ::protobuf::RepeatedField) { + self.external_id = v; + } + + // Mutable pointer to the field. + pub fn mut_external_id(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.external_id + } + + // Take field + pub fn take_external_id(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.external_id, ::protobuf::RepeatedField::new()) + } + + pub fn get_external_id(&self) -> &[ExternalId] { + &self.external_id + } + + // repeated .Disc disc = 11; + + pub fn clear_disc(&mut self) { + self.disc.clear(); + } + + // Param is passed by value, moved + pub fn set_disc(&mut self, v: ::protobuf::RepeatedField) { + self.disc = v; + } + + // Mutable pointer to the field. + pub fn mut_disc(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.disc + } + + // Take field + pub fn take_disc(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.disc, ::protobuf::RepeatedField::new()) + } + + pub fn get_disc(&self) -> &[Disc] { + &self.disc + } + + // repeated string review = 12; + + pub fn clear_review(&mut self) { + self.review.clear(); + } + + // Param is passed by value, moved + pub fn set_review(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.review = v; + } + + // Mutable pointer to the field. + pub fn mut_review(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.review + } + + // Take field + pub fn take_review(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.review, ::protobuf::RepeatedField::new()) + } + + pub fn get_review(&self) -> &[::std::string::String] { + &self.review + } + + // repeated .Copyright copyright = 13; + + pub fn clear_copyright(&mut self) { + self.copyright.clear(); + } + + // Param is passed by value, moved + pub fn set_copyright(&mut self, v: ::protobuf::RepeatedField) { + self.copyright = v; + } + + // Mutable pointer to the field. + pub fn mut_copyright(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.copyright + } + + // Take field + pub fn take_copyright(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.copyright, ::protobuf::RepeatedField::new()) + } + + pub fn get_copyright(&self) -> &[Copyright] { + &self.copyright + } + + // repeated .Restriction restriction = 14; + + pub fn clear_restriction(&mut self) { + self.restriction.clear(); + } + + // Param is passed by value, moved + pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField) { + self.restriction = v; + } + + // Mutable pointer to the field. + pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.restriction + } + + // Take field + pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new()) + } + + pub fn get_restriction(&self) -> &[Restriction] { + &self.restriction + } + + // repeated .Album related = 15; + + pub fn clear_related(&mut self) { + self.related.clear(); + } + + // Param is passed by value, moved + pub fn set_related(&mut self, v: ::protobuf::RepeatedField) { + self.related = v; + } + + // Mutable pointer to the field. + pub fn mut_related(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.related + } + + // Take field + pub fn take_related(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.related, ::protobuf::RepeatedField::new()) + } + + pub fn get_related(&self) -> &[Album] { + &self.related + } + + // repeated .SalePeriod sale_period = 16; + + pub fn clear_sale_period(&mut self) { + self.sale_period.clear(); + } + + // Param is passed by value, moved + pub fn set_sale_period(&mut self, v: ::protobuf::RepeatedField) { + self.sale_period = v; + } + + // Mutable pointer to the field. + pub fn mut_sale_period(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.sale_period + } + + // Take field + pub fn take_sale_period(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.sale_period, ::protobuf::RepeatedField::new()) + } + + pub fn get_sale_period(&self) -> &[SalePeriod] { + &self.sale_period + } + + // optional .ImageGroup cover_group = 17; + + pub fn clear_cover_group(&mut self) { + self.cover_group.clear(); + } + + pub fn has_cover_group(&self) -> bool { + self.cover_group.is_some() + } + + // Param is passed by value, moved + pub fn set_cover_group(&mut self, v: ImageGroup) { + self.cover_group = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cover_group(&mut self) -> &mut ImageGroup { + if self.cover_group.is_none() { + self.cover_group.set_default(); + }; + self.cover_group.as_mut().unwrap() + } + + // Take field + pub fn take_cover_group(&mut self) -> ImageGroup { + self.cover_group.take().unwrap_or_else(|| ImageGroup::new()) + } + + pub fn get_cover_group(&self) -> &ImageGroup { + self.cover_group.as_ref().unwrap_or_else(|| ImageGroup::default_instance()) + } +} + +impl ::protobuf::Message for Album { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)); + }, + 3 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.artist)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 5 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.label)); + }, + 6 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.date)); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.popularity = ::std::option::Option::Some(tmp); + }, + 8 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.genre)); + }, + 9 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.cover)); + }, + 10 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.external_id)); + }, + 11 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.disc)); + }, + 12 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.review)); + }, + 13 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.copyright)); + }, + 14 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)); + }, + 15 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.related)); + }, + 16 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sale_period)); + }, + 17 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cover_group)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gid { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.name { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.artist { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(4, *value); + }; + for value in &self.label { + my_size += ::protobuf::rt::string_size(5, &value); + }; + for value in &self.date { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.popularity { + my_size += ::protobuf::rt::value_varint_zigzag_size(7, *value); + }; + for value in &self.genre { + my_size += ::protobuf::rt::string_size(8, &value); + }; + for value in &self.cover { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.external_id { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.disc { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.review { + my_size += ::protobuf::rt::string_size(12, &value); + }; + for value in &self.copyright { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.restriction { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.related { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.sale_period { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.cover_group { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gid.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.name.as_ref() { + try!(os.write_string(2, &v)); + }; + for v in &self.artist { + try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.typ { + try!(os.write_enum(4, v.value())); + }; + if let Some(v) = self.label.as_ref() { + try!(os.write_string(5, &v)); + }; + if let Some(v) = self.date.as_ref() { + try!(os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.popularity { + try!(os.write_sint32(7, v)); + }; + for v in &self.genre { + try!(os.write_string(8, &v)); + }; + for v in &self.cover { + try!(os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.external_id { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.disc { + try!(os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.review { + try!(os.write_string(12, &v)); + }; + for v in &self.copyright { + try!(os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.restriction { + try!(os.write_tag(14, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.related { + try!(os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.sale_period { + try!(os.write_tag(16, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.cover_group.as_ref() { + try!(os.write_tag(17, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Album { + fn new() -> Album { + Album::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gid", + Album::has_gid, + Album::get_gid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "name", + Album::has_name, + Album::get_name, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "artist", + Album::get_artist, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + Album::has_typ, + Album::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "label", + Album::has_label, + Album::get_label, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "date", + Album::has_date, + Album::get_date, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "popularity", + Album::has_popularity, + Album::get_popularity, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "genre", + Album::get_genre, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "cover", + Album::get_cover, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "external_id", + Album::get_external_id, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "disc", + Album::get_disc, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "review", + Album::get_review, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "copyright", + Album::get_copyright, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "restriction", + Album::get_restriction, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "related", + Album::get_related, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "sale_period", + Album::get_sale_period, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "cover_group", + Album::has_cover_group, + Album::get_cover_group, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Album", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Album { + fn clear(&mut self) { + self.clear_gid(); + self.clear_name(); + self.clear_artist(); + self.clear_typ(); + self.clear_label(); + self.clear_date(); + self.clear_popularity(); + self.clear_genre(); + self.clear_cover(); + self.clear_external_id(); + self.clear_disc(); + self.clear_review(); + self.clear_copyright(); + self.clear_restriction(); + self.clear_related(); + self.clear_sale_period(); + self.clear_cover_group(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Album { + fn eq(&self, other: &Album) -> bool { + self.gid == other.gid && + self.name == other.name && + self.artist == other.artist && + self.typ == other.typ && + self.label == other.label && + self.date == other.date && + self.popularity == other.popularity && + self.genre == other.genre && + self.cover == other.cover && + self.external_id == other.external_id && + self.disc == other.disc && + self.review == other.review && + self.copyright == other.copyright && + self.restriction == other.restriction && + self.related == other.related && + self.sale_period == other.sale_period && + self.cover_group == other.cover_group && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Album { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Album_Type { + ALBUM = 1, + SINGLE = 2, + COMPILATION = 3, +} + +impl ::protobuf::ProtobufEnum for Album_Type { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(Album_Type::ALBUM), + 2 => ::std::option::Option::Some(Album_Type::SINGLE), + 3 => ::std::option::Option::Some(Album_Type::COMPILATION), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Album_Type] = &[ + Album_Type::ALBUM, + Album_Type::SINGLE, + Album_Type::COMPILATION, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Album_Type", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Album_Type { +} + +#[derive(Clone,Default)] +pub struct Track { + // message fields + gid: ::protobuf::SingularField<::std::vec::Vec>, + name: ::protobuf::SingularField<::std::string::String>, + album: ::protobuf::SingularPtrField, + artist: ::protobuf::RepeatedField, + number: ::std::option::Option, + disc_number: ::std::option::Option, + duration: ::std::option::Option, + popularity: ::std::option::Option, + explicit: ::std::option::Option, + external_id: ::protobuf::RepeatedField, + restriction: ::protobuf::RepeatedField, + file: ::protobuf::RepeatedField, + alternative: ::protobuf::RepeatedField, + sale_period: ::protobuf::RepeatedField, + preview: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Track {} + +impl Track { + pub fn new() -> Track { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Track { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Track, + }; + unsafe { + instance.get(|| { + Track { + gid: ::protobuf::SingularField::none(), + name: ::protobuf::SingularField::none(), + album: ::protobuf::SingularPtrField::none(), + artist: ::protobuf::RepeatedField::new(), + number: ::std::option::Option::None, + disc_number: ::std::option::Option::None, + duration: ::std::option::Option::None, + popularity: ::std::option::Option::None, + explicit: ::std::option::Option::None, + external_id: ::protobuf::RepeatedField::new(), + restriction: ::protobuf::RepeatedField::new(), + file: ::protobuf::RepeatedField::new(), + alternative: ::protobuf::RepeatedField::new(), + sale_period: ::protobuf::RepeatedField::new(), + preview: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes gid = 1; + + pub fn clear_gid(&mut self) { + self.gid.clear(); + } + + pub fn has_gid(&self) -> bool { + self.gid.is_some() + } + + // Param is passed by value, moved + pub fn set_gid(&mut self, v: ::std::vec::Vec) { + self.gid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec { + if self.gid.is_none() { + self.gid.set_default(); + }; + self.gid.as_mut().unwrap() + } + + // Take field + pub fn take_gid(&mut self) -> ::std::vec::Vec { + self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gid(&self) -> &[u8] { + match self.gid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string name = 2; + + pub fn clear_name(&mut self) { + self.name.clear(); + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name.set_default(); + }; + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional .Album album = 3; + + pub fn clear_album(&mut self) { + self.album.clear(); + } + + pub fn has_album(&self) -> bool { + self.album.is_some() + } + + // Param is passed by value, moved + pub fn set_album(&mut self, v: Album) { + self.album = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_album(&mut self) -> &mut Album { + if self.album.is_none() { + self.album.set_default(); + }; + self.album.as_mut().unwrap() + } + + // Take field + pub fn take_album(&mut self) -> Album { + self.album.take().unwrap_or_else(|| Album::new()) + } + + pub fn get_album(&self) -> &Album { + self.album.as_ref().unwrap_or_else(|| Album::default_instance()) + } + + // repeated .Artist artist = 4; + + pub fn clear_artist(&mut self) { + self.artist.clear(); + } + + // Param is passed by value, moved + pub fn set_artist(&mut self, v: ::protobuf::RepeatedField) { + self.artist = v; + } + + // Mutable pointer to the field. + pub fn mut_artist(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.artist + } + + // Take field + pub fn take_artist(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.artist, ::protobuf::RepeatedField::new()) + } + + pub fn get_artist(&self) -> &[Artist] { + &self.artist + } + + // optional sint32 number = 5; + + pub fn clear_number(&mut self) { + self.number = ::std::option::Option::None; + } + + pub fn has_number(&self) -> bool { + self.number.is_some() + } + + // Param is passed by value, moved + pub fn set_number(&mut self, v: i32) { + self.number = ::std::option::Option::Some(v); + } + + pub fn get_number(&self) -> i32 { + self.number.unwrap_or(0) + } + + // optional sint32 disc_number = 6; + + pub fn clear_disc_number(&mut self) { + self.disc_number = ::std::option::Option::None; + } + + pub fn has_disc_number(&self) -> bool { + self.disc_number.is_some() + } + + // Param is passed by value, moved + pub fn set_disc_number(&mut self, v: i32) { + self.disc_number = ::std::option::Option::Some(v); + } + + pub fn get_disc_number(&self) -> i32 { + self.disc_number.unwrap_or(0) + } + + // optional sint32 duration = 7; + + pub fn clear_duration(&mut self) { + self.duration = ::std::option::Option::None; + } + + pub fn has_duration(&self) -> bool { + self.duration.is_some() + } + + // Param is passed by value, moved + pub fn set_duration(&mut self, v: i32) { + self.duration = ::std::option::Option::Some(v); + } + + pub fn get_duration(&self) -> i32 { + self.duration.unwrap_or(0) + } + + // optional sint32 popularity = 8; + + pub fn clear_popularity(&mut self) { + self.popularity = ::std::option::Option::None; + } + + pub fn has_popularity(&self) -> bool { + self.popularity.is_some() + } + + // Param is passed by value, moved + pub fn set_popularity(&mut self, v: i32) { + self.popularity = ::std::option::Option::Some(v); + } + + pub fn get_popularity(&self) -> i32 { + self.popularity.unwrap_or(0) + } + + // optional bool explicit = 9; + + pub fn clear_explicit(&mut self) { + self.explicit = ::std::option::Option::None; + } + + pub fn has_explicit(&self) -> bool { + self.explicit.is_some() + } + + // Param is passed by value, moved + pub fn set_explicit(&mut self, v: bool) { + self.explicit = ::std::option::Option::Some(v); + } + + pub fn get_explicit(&self) -> bool { + self.explicit.unwrap_or(false) + } + + // repeated .ExternalId external_id = 10; + + pub fn clear_external_id(&mut self) { + self.external_id.clear(); + } + + // Param is passed by value, moved + pub fn set_external_id(&mut self, v: ::protobuf::RepeatedField) { + self.external_id = v; + } + + // Mutable pointer to the field. + pub fn mut_external_id(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.external_id + } + + // Take field + pub fn take_external_id(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.external_id, ::protobuf::RepeatedField::new()) + } + + pub fn get_external_id(&self) -> &[ExternalId] { + &self.external_id + } + + // repeated .Restriction restriction = 11; + + pub fn clear_restriction(&mut self) { + self.restriction.clear(); + } + + // Param is passed by value, moved + pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField) { + self.restriction = v; + } + + // Mutable pointer to the field. + pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.restriction + } + + // Take field + pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new()) + } + + pub fn get_restriction(&self) -> &[Restriction] { + &self.restriction + } + + // repeated .AudioFile file = 12; + + pub fn clear_file(&mut self) { + self.file.clear(); + } + + // Param is passed by value, moved + pub fn set_file(&mut self, v: ::protobuf::RepeatedField) { + self.file = v; + } + + // Mutable pointer to the field. + pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.file + } + + // Take field + pub fn take_file(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new()) + } + + pub fn get_file(&self) -> &[AudioFile] { + &self.file + } + + // repeated .Track alternative = 13; + + pub fn clear_alternative(&mut self) { + self.alternative.clear(); + } + + // Param is passed by value, moved + pub fn set_alternative(&mut self, v: ::protobuf::RepeatedField) { + self.alternative = v; + } + + // Mutable pointer to the field. + pub fn mut_alternative(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.alternative + } + + // Take field + pub fn take_alternative(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.alternative, ::protobuf::RepeatedField::new()) + } + + pub fn get_alternative(&self) -> &[Track] { + &self.alternative + } + + // repeated .SalePeriod sale_period = 14; + + pub fn clear_sale_period(&mut self) { + self.sale_period.clear(); + } + + // Param is passed by value, moved + pub fn set_sale_period(&mut self, v: ::protobuf::RepeatedField) { + self.sale_period = v; + } + + // Mutable pointer to the field. + pub fn mut_sale_period(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.sale_period + } + + // Take field + pub fn take_sale_period(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.sale_period, ::protobuf::RepeatedField::new()) + } + + pub fn get_sale_period(&self) -> &[SalePeriod] { + &self.sale_period + } + + // repeated .AudioFile preview = 15; + + pub fn clear_preview(&mut self) { + self.preview.clear(); + } + + // Param is passed by value, moved + pub fn set_preview(&mut self, v: ::protobuf::RepeatedField) { + self.preview = v; + } + + // Mutable pointer to the field. + pub fn mut_preview(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.preview + } + + // Take field + pub fn take_preview(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.preview, ::protobuf::RepeatedField::new()) + } + + pub fn get_preview(&self) -> &[AudioFile] { + &self.preview + } +} + +impl ::protobuf::Message for Track { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)); + }, + 3 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.album)); + }, + 4 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.artist)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.number = ::std::option::Option::Some(tmp); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.disc_number = ::std::option::Option::Some(tmp); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.duration = ::std::option::Option::Some(tmp); + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.popularity = ::std::option::Option::Some(tmp); + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.explicit = ::std::option::Option::Some(tmp); + }, + 10 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.external_id)); + }, + 11 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)); + }, + 12 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)); + }, + 13 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.alternative)); + }, + 14 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sale_period)); + }, + 15 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.preview)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gid { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.name { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.album { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.artist { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.number { + my_size += ::protobuf::rt::value_varint_zigzag_size(5, *value); + }; + for value in &self.disc_number { + my_size += ::protobuf::rt::value_varint_zigzag_size(6, *value); + }; + for value in &self.duration { + my_size += ::protobuf::rt::value_varint_zigzag_size(7, *value); + }; + for value in &self.popularity { + my_size += ::protobuf::rt::value_varint_zigzag_size(8, *value); + }; + if self.explicit.is_some() { + my_size += 2; + }; + for value in &self.external_id { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.restriction { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.file { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.alternative { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.sale_period { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.preview { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gid.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.name.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.album.as_ref() { + try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.artist { + try!(os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.number { + try!(os.write_sint32(5, v)); + }; + if let Some(v) = self.disc_number { + try!(os.write_sint32(6, v)); + }; + if let Some(v) = self.duration { + try!(os.write_sint32(7, v)); + }; + if let Some(v) = self.popularity { + try!(os.write_sint32(8, v)); + }; + if let Some(v) = self.explicit { + try!(os.write_bool(9, v)); + }; + for v in &self.external_id { + try!(os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.restriction { + try!(os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.file { + try!(os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.alternative { + try!(os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.sale_period { + try!(os.write_tag(14, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.preview { + try!(os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Track { + fn new() -> Track { + Track::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gid", + Track::has_gid, + Track::get_gid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "name", + Track::has_name, + Track::get_name, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "album", + Track::has_album, + Track::get_album, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "artist", + Track::get_artist, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "number", + Track::has_number, + Track::get_number, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "disc_number", + Track::has_disc_number, + Track::get_disc_number, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "duration", + Track::has_duration, + Track::get_duration, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "popularity", + Track::has_popularity, + Track::get_popularity, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "explicit", + Track::has_explicit, + Track::get_explicit, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "external_id", + Track::get_external_id, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "restriction", + Track::get_restriction, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "file", + Track::get_file, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "alternative", + Track::get_alternative, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "sale_period", + Track::get_sale_period, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "preview", + Track::get_preview, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Track", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Track { + fn clear(&mut self) { + self.clear_gid(); + self.clear_name(); + self.clear_album(); + self.clear_artist(); + self.clear_number(); + self.clear_disc_number(); + self.clear_duration(); + self.clear_popularity(); + self.clear_explicit(); + self.clear_external_id(); + self.clear_restriction(); + self.clear_file(); + self.clear_alternative(); + self.clear_sale_period(); + self.clear_preview(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Track { + fn eq(&self, other: &Track) -> bool { + self.gid == other.gid && + self.name == other.name && + self.album == other.album && + self.artist == other.artist && + self.number == other.number && + self.disc_number == other.disc_number && + self.duration == other.duration && + self.popularity == other.popularity && + self.explicit == other.explicit && + self.external_id == other.external_id && + self.restriction == other.restriction && + self.file == other.file && + self.alternative == other.alternative && + self.sale_period == other.sale_period && + self.preview == other.preview && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Track { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Image { + // message fields + file_id: ::protobuf::SingularField<::std::vec::Vec>, + size: ::std::option::Option, + width: ::std::option::Option, + height: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Image {} + +impl Image { + pub fn new() -> Image { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Image { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Image, + }; + unsafe { + instance.get(|| { + Image { + file_id: ::protobuf::SingularField::none(), + size: ::std::option::Option::None, + width: ::std::option::Option::None, + height: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes file_id = 1; + + pub fn clear_file_id(&mut self) { + self.file_id.clear(); + } + + pub fn has_file_id(&self) -> bool { + self.file_id.is_some() + } + + // Param is passed by value, moved + pub fn set_file_id(&mut self, v: ::std::vec::Vec) { + self.file_id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_file_id(&mut self) -> &mut ::std::vec::Vec { + if self.file_id.is_none() { + self.file_id.set_default(); + }; + self.file_id.as_mut().unwrap() + } + + // Take field + pub fn take_file_id(&mut self) -> ::std::vec::Vec { + self.file_id.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_file_id(&self) -> &[u8] { + match self.file_id.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional .Image.Size size = 2; + + pub fn clear_size(&mut self) { + self.size = ::std::option::Option::None; + } + + pub fn has_size(&self) -> bool { + self.size.is_some() + } + + // Param is passed by value, moved + pub fn set_size(&mut self, v: Image_Size) { + self.size = ::std::option::Option::Some(v); + } + + pub fn get_size(&self) -> Image_Size { + self.size.unwrap_or(Image_Size::DEFAULT) + } + + // optional sint32 width = 3; + + pub fn clear_width(&mut self) { + self.width = ::std::option::Option::None; + } + + pub fn has_width(&self) -> bool { + self.width.is_some() + } + + // Param is passed by value, moved + pub fn set_width(&mut self, v: i32) { + self.width = ::std::option::Option::Some(v); + } + + pub fn get_width(&self) -> i32 { + self.width.unwrap_or(0) + } + + // optional sint32 height = 4; + + pub fn clear_height(&mut self) { + self.height = ::std::option::Option::None; + } + + pub fn has_height(&self) -> bool { + self.height.is_some() + } + + // Param is passed by value, moved + pub fn set_height(&mut self, v: i32) { + self.height = ::std::option::Option::Some(v); + } + + pub fn get_height(&self) -> i32 { + self.height.unwrap_or(0) + } +} + +impl ::protobuf::Message for Image { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.file_id)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.size = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.width = ::std::option::Option::Some(tmp); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.height = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.file_id { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.size { + my_size += ::protobuf::rt::enum_size(2, *value); + }; + for value in &self.width { + my_size += ::protobuf::rt::value_varint_zigzag_size(3, *value); + }; + for value in &self.height { + my_size += ::protobuf::rt::value_varint_zigzag_size(4, *value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.file_id.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.size { + try!(os.write_enum(2, v.value())); + }; + if let Some(v) = self.width { + try!(os.write_sint32(3, v)); + }; + if let Some(v) = self.height { + try!(os.write_sint32(4, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Image { + fn new() -> Image { + Image::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "file_id", + Image::has_file_id, + Image::get_file_id, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "size", + Image::has_size, + Image::get_size, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "width", + Image::has_width, + Image::get_width, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "height", + Image::has_height, + Image::get_height, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Image", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Image { + fn clear(&mut self) { + self.clear_file_id(); + self.clear_size(); + self.clear_width(); + self.clear_height(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Image { + fn eq(&self, other: &Image) -> bool { + self.file_id == other.file_id && + self.size == other.size && + self.width == other.width && + self.height == other.height && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Image { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Image_Size { + DEFAULT = 0, + SMALL = 1, + LARGE = 2, + XLARGE = 3, +} + +impl ::protobuf::ProtobufEnum for Image_Size { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Image_Size::DEFAULT), + 1 => ::std::option::Option::Some(Image_Size::SMALL), + 2 => ::std::option::Option::Some(Image_Size::LARGE), + 3 => ::std::option::Option::Some(Image_Size::XLARGE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Image_Size] = &[ + Image_Size::DEFAULT, + Image_Size::SMALL, + Image_Size::LARGE, + Image_Size::XLARGE, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Image_Size", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Image_Size { +} + +#[derive(Clone,Default)] +pub struct ImageGroup { + // message fields + image: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ImageGroup {} + +impl ImageGroup { + pub fn new() -> ImageGroup { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ImageGroup { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ImageGroup, + }; + unsafe { + instance.get(|| { + ImageGroup { + image: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // repeated .Image image = 1; + + pub fn clear_image(&mut self) { + self.image.clear(); + } + + // Param is passed by value, moved + pub fn set_image(&mut self, v: ::protobuf::RepeatedField) { + self.image = v; + } + + // Mutable pointer to the field. + pub fn mut_image(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.image + } + + // Take field + pub fn take_image(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.image, ::protobuf::RepeatedField::new()) + } + + pub fn get_image(&self) -> &[Image] { + &self.image + } +} + +impl ::protobuf::Message for ImageGroup { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.image)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.image { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.image { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ImageGroup { + fn new() -> ImageGroup { + ImageGroup::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "image", + ImageGroup::get_image, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ImageGroup", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ImageGroup { + fn clear(&mut self) { + self.clear_image(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ImageGroup { + fn eq(&self, other: &ImageGroup) -> bool { + self.image == other.image && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ImageGroup { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Biography { + // message fields + text: ::protobuf::SingularField<::std::string::String>, + portrait: ::protobuf::RepeatedField, + portrait_group: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Biography {} + +impl Biography { + pub fn new() -> Biography { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Biography { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Biography, + }; + unsafe { + instance.get(|| { + Biography { + text: ::protobuf::SingularField::none(), + portrait: ::protobuf::RepeatedField::new(), + portrait_group: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string text = 1; + + pub fn clear_text(&mut self) { + self.text.clear(); + } + + pub fn has_text(&self) -> bool { + self.text.is_some() + } + + // Param is passed by value, moved + pub fn set_text(&mut self, v: ::std::string::String) { + self.text = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_text(&mut self) -> &mut ::std::string::String { + if self.text.is_none() { + self.text.set_default(); + }; + self.text.as_mut().unwrap() + } + + // Take field + pub fn take_text(&mut self) -> ::std::string::String { + self.text.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_text(&self) -> &str { + match self.text.as_ref() { + Some(v) => &v, + None => "", + } + } + + // repeated .Image portrait = 2; + + pub fn clear_portrait(&mut self) { + self.portrait.clear(); + } + + // Param is passed by value, moved + pub fn set_portrait(&mut self, v: ::protobuf::RepeatedField) { + self.portrait = v; + } + + // Mutable pointer to the field. + pub fn mut_portrait(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.portrait + } + + // Take field + pub fn take_portrait(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.portrait, ::protobuf::RepeatedField::new()) + } + + pub fn get_portrait(&self) -> &[Image] { + &self.portrait + } + + // repeated .ImageGroup portrait_group = 3; + + pub fn clear_portrait_group(&mut self) { + self.portrait_group.clear(); + } + + // Param is passed by value, moved + pub fn set_portrait_group(&mut self, v: ::protobuf::RepeatedField) { + self.portrait_group = v; + } + + // Mutable pointer to the field. + pub fn mut_portrait_group(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.portrait_group + } + + // Take field + pub fn take_portrait_group(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.portrait_group, ::protobuf::RepeatedField::new()) + } + + pub fn get_portrait_group(&self) -> &[ImageGroup] { + &self.portrait_group + } +} + +impl ::protobuf::Message for Biography { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.text)); + }, + 2 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.portrait)); + }, + 3 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.portrait_group)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.text { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.portrait { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.portrait_group { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.text.as_ref() { + try!(os.write_string(1, &v)); + }; + for v in &self.portrait { + try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + for v in &self.portrait_group { + try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Biography { + fn new() -> Biography { + Biography::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "text", + Biography::has_text, + Biography::get_text, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "portrait", + Biography::get_portrait, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "portrait_group", + Biography::get_portrait_group, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Biography", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Biography { + fn clear(&mut self) { + self.clear_text(); + self.clear_portrait(); + self.clear_portrait_group(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Biography { + fn eq(&self, other: &Biography) -> bool { + self.text == other.text && + self.portrait == other.portrait && + self.portrait_group == other.portrait_group && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Biography { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Disc { + // message fields + number: ::std::option::Option, + name: ::protobuf::SingularField<::std::string::String>, + track: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Disc {} + +impl Disc { + pub fn new() -> Disc { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Disc { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Disc, + }; + unsafe { + instance.get(|| { + Disc { + number: ::std::option::Option::None, + name: ::protobuf::SingularField::none(), + track: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional sint32 number = 1; + + pub fn clear_number(&mut self) { + self.number = ::std::option::Option::None; + } + + pub fn has_number(&self) -> bool { + self.number.is_some() + } + + // Param is passed by value, moved + pub fn set_number(&mut self, v: i32) { + self.number = ::std::option::Option::Some(v); + } + + pub fn get_number(&self) -> i32 { + self.number.unwrap_or(0) + } + + // optional string name = 2; + + pub fn clear_name(&mut self) { + self.name.clear(); + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name.set_default(); + }; + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + + // repeated .Track track = 3; + + pub fn clear_track(&mut self) { + self.track.clear(); + } + + // Param is passed by value, moved + pub fn set_track(&mut self, v: ::protobuf::RepeatedField) { + self.track = v; + } + + // Mutable pointer to the field. + pub fn mut_track(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.track + } + + // Take field + pub fn take_track(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.track, ::protobuf::RepeatedField::new()) + } + + pub fn get_track(&self) -> &[Track] { + &self.track + } +} + +impl ::protobuf::Message for Disc { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_sint32()); + self.number = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)); + }, + 3 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.track)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.number { + my_size += ::protobuf::rt::value_varint_zigzag_size(1, *value); + }; + for value in &self.name { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.track { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.number { + try!(os.write_sint32(1, v)); + }; + if let Some(v) = self.name.as_ref() { + try!(os.write_string(2, &v)); + }; + for v in &self.track { + try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Disc { + fn new() -> Disc { + Disc::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "number", + Disc::has_number, + Disc::get_number, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "name", + Disc::has_name, + Disc::get_name, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "track", + Disc::get_track, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Disc", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Disc { + fn clear(&mut self) { + self.clear_number(); + self.clear_name(); + self.clear_track(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Disc { + fn eq(&self, other: &Disc) -> bool { + self.number == other.number && + self.name == other.name && + self.track == other.track && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Disc { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Copyright { + // message fields + typ: ::std::option::Option, + text: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Copyright {} + +impl Copyright { + pub fn new() -> Copyright { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Copyright { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Copyright, + }; + unsafe { + instance.get(|| { + Copyright { + typ: ::std::option::Option::None, + text: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .Copyright.Type typ = 1; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: Copyright_Type) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> Copyright_Type { + self.typ.unwrap_or(Copyright_Type::P) + } + + // optional string text = 2; + + pub fn clear_text(&mut self) { + self.text.clear(); + } + + pub fn has_text(&self) -> bool { + self.text.is_some() + } + + // Param is passed by value, moved + pub fn set_text(&mut self, v: ::std::string::String) { + self.text = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_text(&mut self) -> &mut ::std::string::String { + if self.text.is_none() { + self.text.set_default(); + }; + self.text.as_mut().unwrap() + } + + // Take field + pub fn take_text(&mut self) -> ::std::string::String { + self.text.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_text(&self) -> &str { + match self.text.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for Copyright { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.text)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(1, *value); + }; + for value in &self.text { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.typ { + try!(os.write_enum(1, v.value())); + }; + if let Some(v) = self.text.as_ref() { + try!(os.write_string(2, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Copyright { + fn new() -> Copyright { + Copyright::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + Copyright::has_typ, + Copyright::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "text", + Copyright::has_text, + Copyright::get_text, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Copyright", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Copyright { + fn clear(&mut self) { + self.clear_typ(); + self.clear_text(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Copyright { + fn eq(&self, other: &Copyright) -> bool { + self.typ == other.typ && + self.text == other.text && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Copyright { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Copyright_Type { + P = 0, + C = 1, +} + +impl ::protobuf::ProtobufEnum for Copyright_Type { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Copyright_Type::P), + 1 => ::std::option::Option::Some(Copyright_Type::C), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Copyright_Type] = &[ + Copyright_Type::P, + Copyright_Type::C, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Copyright_Type", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Copyright_Type { +} + +#[derive(Clone,Default)] +pub struct Restriction { + // message fields + countries_allowed: ::protobuf::SingularField<::std::string::String>, + countries_forbidden: ::protobuf::SingularField<::std::string::String>, + typ: ::std::option::Option, + catalogue_str: ::protobuf::RepeatedField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Restriction {} + +impl Restriction { + pub fn new() -> Restriction { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Restriction { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Restriction, + }; + unsafe { + instance.get(|| { + Restriction { + countries_allowed: ::protobuf::SingularField::none(), + countries_forbidden: ::protobuf::SingularField::none(), + typ: ::std::option::Option::None, + catalogue_str: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string countries_allowed = 2; + + pub fn clear_countries_allowed(&mut self) { + self.countries_allowed.clear(); + } + + pub fn has_countries_allowed(&self) -> bool { + self.countries_allowed.is_some() + } + + // Param is passed by value, moved + pub fn set_countries_allowed(&mut self, v: ::std::string::String) { + self.countries_allowed = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_countries_allowed(&mut self) -> &mut ::std::string::String { + if self.countries_allowed.is_none() { + self.countries_allowed.set_default(); + }; + self.countries_allowed.as_mut().unwrap() + } + + // Take field + pub fn take_countries_allowed(&mut self) -> ::std::string::String { + self.countries_allowed.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_countries_allowed(&self) -> &str { + match self.countries_allowed.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string countries_forbidden = 3; + + pub fn clear_countries_forbidden(&mut self) { + self.countries_forbidden.clear(); + } + + pub fn has_countries_forbidden(&self) -> bool { + self.countries_forbidden.is_some() + } + + // Param is passed by value, moved + pub fn set_countries_forbidden(&mut self, v: ::std::string::String) { + self.countries_forbidden = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_countries_forbidden(&mut self) -> &mut ::std::string::String { + if self.countries_forbidden.is_none() { + self.countries_forbidden.set_default(); + }; + self.countries_forbidden.as_mut().unwrap() + } + + // Take field + pub fn take_countries_forbidden(&mut self) -> ::std::string::String { + self.countries_forbidden.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_countries_forbidden(&self) -> &str { + match self.countries_forbidden.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional .Restriction.Type typ = 4; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: Restriction_Type) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> Restriction_Type { + self.typ.unwrap_or(Restriction_Type::STREAMING) + } + + // repeated string catalogue_str = 5; + + pub fn clear_catalogue_str(&mut self) { + self.catalogue_str.clear(); + } + + // Param is passed by value, moved + pub fn set_catalogue_str(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.catalogue_str = v; + } + + // Mutable pointer to the field. + pub fn mut_catalogue_str(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.catalogue_str + } + + // Take field + pub fn take_catalogue_str(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.catalogue_str, ::protobuf::RepeatedField::new()) + } + + pub fn get_catalogue_str(&self) -> &[::std::string::String] { + &self.catalogue_str + } +} + +impl ::protobuf::Message for Restriction { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.countries_allowed)); + }, + 3 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.countries_forbidden)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 5 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.catalogue_str)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.countries_allowed { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.countries_forbidden { + my_size += ::protobuf::rt::string_size(3, &value); + }; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(4, *value); + }; + for value in &self.catalogue_str { + my_size += ::protobuf::rt::string_size(5, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.countries_allowed.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.countries_forbidden.as_ref() { + try!(os.write_string(3, &v)); + }; + if let Some(v) = self.typ { + try!(os.write_enum(4, v.value())); + }; + for v in &self.catalogue_str { + try!(os.write_string(5, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Restriction { + fn new() -> Restriction { + Restriction::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "countries_allowed", + Restriction::has_countries_allowed, + Restriction::get_countries_allowed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "countries_forbidden", + Restriction::has_countries_forbidden, + Restriction::get_countries_forbidden, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + Restriction::has_typ, + Restriction::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "catalogue_str", + Restriction::get_catalogue_str, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Restriction", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Restriction { + fn clear(&mut self) { + self.clear_countries_allowed(); + self.clear_countries_forbidden(); + self.clear_typ(); + self.clear_catalogue_str(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Restriction { + fn eq(&self, other: &Restriction) -> bool { + self.countries_allowed == other.countries_allowed && + self.countries_forbidden == other.countries_forbidden && + self.typ == other.typ && + self.catalogue_str == other.catalogue_str && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Restriction { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Restriction_Type { + STREAMING = 0, +} + +impl ::protobuf::ProtobufEnum for Restriction_Type { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Restriction_Type::STREAMING), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Restriction_Type] = &[ + Restriction_Type::STREAMING, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Restriction_Type", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Restriction_Type { +} + +#[derive(Clone,Default)] +pub struct SalePeriod { + // message fields + restriction: ::protobuf::RepeatedField, + start: ::protobuf::SingularPtrField, + end: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for SalePeriod {} + +impl SalePeriod { + pub fn new() -> SalePeriod { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static SalePeriod { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SalePeriod, + }; + unsafe { + instance.get(|| { + SalePeriod { + restriction: ::protobuf::RepeatedField::new(), + start: ::protobuf::SingularPtrField::none(), + end: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // repeated .Restriction restriction = 1; + + pub fn clear_restriction(&mut self) { + self.restriction.clear(); + } + + // Param is passed by value, moved + pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField) { + self.restriction = v; + } + + // Mutable pointer to the field. + pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.restriction + } + + // Take field + pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new()) + } + + pub fn get_restriction(&self) -> &[Restriction] { + &self.restriction + } + + // optional .Date start = 2; + + pub fn clear_start(&mut self) { + self.start.clear(); + } + + pub fn has_start(&self) -> bool { + self.start.is_some() + } + + // Param is passed by value, moved + pub fn set_start(&mut self, v: Date) { + self.start = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_start(&mut self) -> &mut Date { + if self.start.is_none() { + self.start.set_default(); + }; + self.start.as_mut().unwrap() + } + + // Take field + pub fn take_start(&mut self) -> Date { + self.start.take().unwrap_or_else(|| Date::new()) + } + + pub fn get_start(&self) -> &Date { + self.start.as_ref().unwrap_or_else(|| Date::default_instance()) + } + + // optional .Date end = 3; + + pub fn clear_end(&mut self) { + self.end.clear(); + } + + pub fn has_end(&self) -> bool { + self.end.is_some() + } + + // Param is passed by value, moved + pub fn set_end(&mut self, v: Date) { + self.end = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_end(&mut self) -> &mut Date { + if self.end.is_none() { + self.end.set_default(); + }; + self.end.as_mut().unwrap() + } + + // Take field + pub fn take_end(&mut self) -> Date { + self.end.take().unwrap_or_else(|| Date::new()) + } + + pub fn get_end(&self) -> &Date { + self.end.as_ref().unwrap_or_else(|| Date::default_instance()) + } +} + +impl ::protobuf::Message for SalePeriod { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)); + }, + 2 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.start)); + }, + 3 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.end)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.restriction { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.start { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.end { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.restriction { + try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.start.as_ref() { + try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.end.as_ref() { + try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for SalePeriod { + fn new() -> SalePeriod { + SalePeriod::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "restriction", + SalePeriod::get_restriction, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "start", + SalePeriod::has_start, + SalePeriod::get_start, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "end", + SalePeriod::has_end, + SalePeriod::get_end, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SalePeriod", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for SalePeriod { + fn clear(&mut self) { + self.clear_restriction(); + self.clear_start(); + self.clear_end(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for SalePeriod { + fn eq(&self, other: &SalePeriod) -> bool { + self.restriction == other.restriction && + self.start == other.start && + self.end == other.end && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for SalePeriod { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct ExternalId { + // message fields + typ: ::protobuf::SingularField<::std::string::String>, + id: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for ExternalId {} + +impl ExternalId { + pub fn new() -> ExternalId { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static ExternalId { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ExternalId, + }; + unsafe { + instance.get(|| { + ExternalId { + typ: ::protobuf::SingularField::none(), + id: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string typ = 1; + + pub fn clear_typ(&mut self) { + self.typ.clear(); + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: ::std::string::String) { + self.typ = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_typ(&mut self) -> &mut ::std::string::String { + if self.typ.is_none() { + self.typ.set_default(); + }; + self.typ.as_mut().unwrap() + } + + // Take field + pub fn take_typ(&mut self) -> ::std::string::String { + self.typ.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_typ(&self) -> &str { + match self.typ.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string id = 2; + + pub fn clear_id(&mut self) { + self.id.clear(); + } + + pub fn has_id(&self) -> bool { + self.id.is_some() + } + + // Param is passed by value, moved + pub fn set_id(&mut self, v: ::std::string::String) { + self.id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_id(&mut self) -> &mut ::std::string::String { + if self.id.is_none() { + self.id.set_default(); + }; + self.id.as_mut().unwrap() + } + + // Take field + pub fn take_id(&mut self) -> ::std::string::String { + self.id.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_id(&self) -> &str { + match self.id.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for ExternalId { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.typ)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.id)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.typ { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.id { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.typ.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.id.as_ref() { + try!(os.write_string(2, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for ExternalId { + fn new() -> ExternalId { + ExternalId::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "typ", + ExternalId::has_typ, + ExternalId::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "id", + ExternalId::has_id, + ExternalId::get_id, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ExternalId", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for ExternalId { + fn clear(&mut self) { + self.clear_typ(); + self.clear_id(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for ExternalId { + fn eq(&self, other: &ExternalId) -> bool { + self.typ == other.typ && + self.id == other.id && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for ExternalId { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct AudioFile { + // message fields + file_id: ::protobuf::SingularField<::std::vec::Vec>, + format: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for AudioFile {} + +impl AudioFile { + pub fn new() -> AudioFile { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static AudioFile { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AudioFile, + }; + unsafe { + instance.get(|| { + AudioFile { + file_id: ::protobuf::SingularField::none(), + format: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes file_id = 1; + + pub fn clear_file_id(&mut self) { + self.file_id.clear(); + } + + pub fn has_file_id(&self) -> bool { + self.file_id.is_some() + } + + // Param is passed by value, moved + pub fn set_file_id(&mut self, v: ::std::vec::Vec) { + self.file_id = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_file_id(&mut self) -> &mut ::std::vec::Vec { + if self.file_id.is_none() { + self.file_id.set_default(); + }; + self.file_id.as_mut().unwrap() + } + + // Take field + pub fn take_file_id(&mut self) -> ::std::vec::Vec { + self.file_id.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_file_id(&self) -> &[u8] { + match self.file_id.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional .AudioFile.Format format = 2; + + pub fn clear_format(&mut self) { + self.format = ::std::option::Option::None; + } + + pub fn has_format(&self) -> bool { + self.format.is_some() + } + + // Param is passed by value, moved + pub fn set_format(&mut self, v: AudioFile_Format) { + self.format = ::std::option::Option::Some(v); + } + + pub fn get_format(&self) -> AudioFile_Format { + self.format.unwrap_or(AudioFile_Format::OGG_VORBIS_96) + } +} + +impl ::protobuf::Message for AudioFile { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.file_id)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.format = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.file_id { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.format { + my_size += ::protobuf::rt::enum_size(2, *value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.file_id.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.format { + try!(os.write_enum(2, v.value())); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for AudioFile { + fn new() -> AudioFile { + AudioFile::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "file_id", + AudioFile::has_file_id, + AudioFile::get_file_id, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "format", + AudioFile::has_format, + AudioFile::get_format, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AudioFile", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for AudioFile { + fn clear(&mut self) { + self.clear_file_id(); + self.clear_format(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for AudioFile { + fn eq(&self, other: &AudioFile) -> bool { + self.file_id == other.file_id && + self.format == other.format && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for AudioFile { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum AudioFile_Format { + OGG_VORBIS_96 = 0, + OGG_VORBIS_160 = 1, + OGG_VORBIS_320 = 2, + MP3_256 = 3, + MP3_320 = 4, + MP3_160 = 5, + MP3_96 = 6, + MP3_160_ENC = 7, + OTHER2 = 8, + OTHER3 = 9, + AAC_160 = 10, + AAC_320 = 11, +} + +impl ::protobuf::ProtobufEnum for AudioFile_Format { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(AudioFile_Format::OGG_VORBIS_96), + 1 => ::std::option::Option::Some(AudioFile_Format::OGG_VORBIS_160), + 2 => ::std::option::Option::Some(AudioFile_Format::OGG_VORBIS_320), + 3 => ::std::option::Option::Some(AudioFile_Format::MP3_256), + 4 => ::std::option::Option::Some(AudioFile_Format::MP3_320), + 5 => ::std::option::Option::Some(AudioFile_Format::MP3_160), + 6 => ::std::option::Option::Some(AudioFile_Format::MP3_96), + 7 => ::std::option::Option::Some(AudioFile_Format::MP3_160_ENC), + 8 => ::std::option::Option::Some(AudioFile_Format::OTHER2), + 9 => ::std::option::Option::Some(AudioFile_Format::OTHER3), + 10 => ::std::option::Option::Some(AudioFile_Format::AAC_160), + 11 => ::std::option::Option::Some(AudioFile_Format::AAC_320), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [AudioFile_Format] = &[ + AudioFile_Format::OGG_VORBIS_96, + AudioFile_Format::OGG_VORBIS_160, + AudioFile_Format::OGG_VORBIS_320, + AudioFile_Format::MP3_256, + AudioFile_Format::MP3_320, + AudioFile_Format::MP3_160, + AudioFile_Format::MP3_96, + AudioFile_Format::MP3_160_ENC, + AudioFile_Format::OTHER2, + AudioFile_Format::OTHER3, + AudioFile_Format::AAC_160, + AudioFile_Format::AAC_320, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("AudioFile_Format", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for AudioFile_Format { +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x0e, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x43, 0x0a, 0x09, 0x54, 0x6f, 0x70, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x12, 0x18, 0x0a, + 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x1c, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x6b, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, 0x05, + 0x74, 0x72, 0x61, 0x63, 0x6b, 0x22, 0x62, 0x0a, 0x0e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x59, 0x65, 0x61, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x79, 0x65, + 0x61, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x59, 0x65, 0x61, + 0x72, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x65, 0x63, 0x61, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x11, 0x52, 0x06, 0x64, 0x65, 0x63, 0x61, 0x64, 0x65, 0x22, 0xd0, 0x05, 0x0a, 0x06, 0x41, 0x72, + 0x74, 0x69, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x03, 0x67, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x6f, + 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0a, + 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x12, 0x27, 0x0a, 0x09, 0x74, 0x6f, + 0x70, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, + 0x54, 0x6f, 0x70, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x54, 0x72, + 0x61, 0x63, 0x6b, 0x12, 0x2c, 0x0a, 0x0b, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x41, 0x6c, 0x62, 0x75, 0x6d, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0a, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x12, 0x2e, 0x0a, 0x0c, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0b, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x12, 0x38, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x41, + 0x6c, 0x62, 0x75, 0x6d, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x69, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x35, 0x0a, 0x10, 0x61, + 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x5f, 0x6f, 0x6e, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x52, 0x0e, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x4f, 0x6e, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x12, 0x2c, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, + 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x08, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, + 0x69, 0x74, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x52, 0x08, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x12, 0x28, 0x0a, 0x09, 0x62, 0x69, + 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, + 0x42, 0x69, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x52, 0x09, 0x62, 0x69, 0x6f, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x79, 0x12, 0x38, 0x0a, 0x0f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, + 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x0e, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x2e, + 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, + 0x0a, 0x07, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x07, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, + 0x64, 0x12, 0x35, 0x0a, 0x17, 0x69, 0x73, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, + 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x18, 0x10, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x14, 0x69, 0x73, 0x50, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x41, 0x6c, + 0x62, 0x75, 0x6d, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x0e, 0x70, 0x6f, 0x72, 0x74, + 0x72, 0x61, 0x69, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0b, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x70, + 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x2a, 0x0a, 0x0a, + 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1c, 0x0a, 0x05, 0x61, 0x6c, + 0x62, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x41, 0x6c, 0x62, 0x75, + 0x6d, 0x52, 0x05, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x22, 0x42, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x04, + 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x11, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x64, 0x61, 0x79, 0x22, 0xdb, 0x04, 0x0a, + 0x05, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x03, 0x67, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x06, + 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x41, + 0x72, 0x74, 0x69, 0x73, 0x74, 0x52, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x1d, 0x0a, + 0x03, 0x74, 0x79, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0b, 0x2e, 0x41, 0x6c, 0x62, + 0x75, 0x6d, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x03, 0x74, 0x79, 0x70, 0x12, 0x14, 0x0a, 0x05, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x12, 0x19, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x05, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1e, 0x0a, + 0x0a, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x11, 0x52, 0x0a, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x67, 0x65, + 0x6e, 0x72, 0x65, 0x12, 0x1c, 0x0a, 0x05, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x18, 0x09, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x05, 0x63, 0x6f, 0x76, 0x65, + 0x72, 0x12, 0x2c, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, + 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x49, 0x64, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, + 0x19, 0x0a, 0x04, 0x64, 0x69, 0x73, 0x63, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x05, 0x2e, + 0x44, 0x69, 0x73, 0x63, 0x52, 0x04, 0x64, 0x69, 0x73, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, + 0x76, 0x69, 0x65, 0x77, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x76, 0x69, + 0x65, 0x77, 0x12, 0x28, 0x0a, 0x09, 0x63, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x52, 0x09, 0x63, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2e, 0x0a, 0x0b, + 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x0c, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0b, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x07, + 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, + 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x52, 0x07, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2c, + 0x0a, 0x0b, 0x73, 0x61, 0x6c, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x10, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x52, 0x0a, 0x73, 0x61, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x2c, 0x0a, 0x0b, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x11, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0b, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0a, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x2e, 0x0a, 0x04, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x4c, 0x42, 0x55, 0x4d, 0x10, 0x01, 0x12, 0x0a, 0x0a, + 0x06, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4f, 0x4d, + 0x50, 0x49, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x03, 0x22, 0xf9, 0x03, 0x0a, 0x05, 0x54, + 0x72, 0x61, 0x63, 0x6b, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x03, 0x67, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x05, 0x61, 0x6c, + 0x62, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x41, 0x6c, 0x62, 0x75, + 0x6d, 0x52, 0x05, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x12, 0x1f, 0x0a, 0x06, 0x61, 0x72, 0x74, 0x69, + 0x73, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x73, + 0x74, 0x52, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x69, 0x73, 0x63, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0a, 0x64, 0x69, 0x73, 0x63, 0x4e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x11, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, + 0x0a, 0x0a, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x11, 0x52, 0x0a, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x08, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x0b, 0x65, 0x78, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x0b, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x52, 0x0a, 0x65, 0x78, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x74, + 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, + 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x73, + 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, + 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x6f, 0x46, 0x69, + 0x6c, 0x65, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x28, 0x0a, 0x0b, 0x61, 0x6c, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, + 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, 0x0b, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x12, 0x2c, 0x0a, 0x0b, 0x73, 0x61, 0x6c, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, + 0x64, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x52, 0x0a, 0x73, 0x61, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x12, 0x24, 0x0a, 0x07, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x18, 0x0f, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x0a, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x07, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x22, 0xa6, 0x01, 0x0a, 0x05, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x12, 0x17, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x04, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0b, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x2e, + 0x53, 0x69, 0x7a, 0x65, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x77, 0x69, + 0x64, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x77, 0x69, 0x64, 0x74, 0x68, + 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x11, + 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x35, 0x0a, 0x04, 0x53, 0x69, 0x7a, 0x65, + 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x10, 0x00, 0x12, 0x09, 0x0a, + 0x05, 0x53, 0x4d, 0x41, 0x4c, 0x4c, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x4c, 0x41, 0x52, 0x47, + 0x45, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x58, 0x4c, 0x41, 0x52, 0x47, 0x45, 0x10, 0x03, 0x22, + 0x2a, 0x0a, 0x0a, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1c, 0x0a, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x22, 0x77, 0x0a, 0x09, 0x42, + 0x69, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x65, 0x78, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x65, 0x78, 0x74, 0x12, 0x22, 0x0a, 0x08, + 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, + 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x08, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, + 0x12, 0x32, 0x0a, 0x0e, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x5f, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x22, 0x50, 0x0a, 0x04, 0x44, 0x69, 0x73, 0x63, 0x12, 0x16, 0x0a, 0x06, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x06, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, + 0x6b, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, + 0x05, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x22, 0x58, 0x0a, 0x09, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x12, 0x21, 0x0a, 0x03, 0x74, 0x79, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x0f, 0x2e, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x03, 0x74, 0x79, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x65, 0x78, 0x74, 0x22, 0x14, 0x0a, 0x04, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x05, 0x0a, 0x01, 0x50, 0x10, 0x00, 0x12, 0x05, 0x0a, 0x01, 0x43, 0x10, 0x01, + 0x22, 0xcc, 0x01, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5f, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, 0x2f, 0x0a, + 0x13, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5f, 0x66, 0x6f, 0x72, 0x62, 0x69, + 0x64, 0x64, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x72, 0x69, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x12, 0x23, + 0x0a, 0x03, 0x74, 0x79, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x52, 0x65, + 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x03, + 0x74, 0x79, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, + 0x5f, 0x73, 0x74, 0x72, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x53, 0x74, 0x72, 0x22, 0x15, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x54, 0x52, 0x45, 0x41, 0x4d, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x22, + 0x72, 0x0a, 0x0a, 0x53, 0x61, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x2e, 0x0a, + 0x0b, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0b, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, + 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x44, + 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x17, 0x0a, 0x03, 0x65, 0x6e, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x52, 0x03, + 0x65, 0x6e, 0x64, 0x22, 0x2e, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, + 0x64, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x79, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x74, 0x79, 0x70, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x02, 0x69, 0x64, 0x22, 0x8b, 0x02, 0x0a, 0x09, 0x41, 0x75, 0x64, 0x69, 0x6f, 0x46, 0x69, 0x6c, + 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x06, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x41, 0x75, 0x64, + 0x69, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0xb9, 0x01, 0x0a, 0x06, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x47, 0x47, 0x5f, 0x56, 0x4f, 0x52, 0x42, 0x49, 0x53, 0x5f, 0x39, + 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x47, 0x47, 0x5f, 0x56, 0x4f, 0x52, 0x42, 0x49, + 0x53, 0x5f, 0x31, 0x36, 0x30, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x47, 0x47, 0x5f, 0x56, + 0x4f, 0x52, 0x42, 0x49, 0x53, 0x5f, 0x33, 0x32, 0x30, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x4d, + 0x50, 0x33, 0x5f, 0x32, 0x35, 0x36, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x4d, 0x50, 0x33, 0x5f, + 0x33, 0x32, 0x30, 0x10, 0x04, 0x12, 0x0b, 0x0a, 0x07, 0x4d, 0x50, 0x33, 0x5f, 0x31, 0x36, 0x30, + 0x10, 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x50, 0x33, 0x5f, 0x39, 0x36, 0x10, 0x06, 0x12, 0x0f, + 0x0a, 0x0b, 0x4d, 0x50, 0x33, 0x5f, 0x31, 0x36, 0x30, 0x5f, 0x45, 0x4e, 0x43, 0x10, 0x07, 0x12, + 0x0a, 0x0a, 0x06, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x32, 0x10, 0x08, 0x12, 0x0a, 0x0a, 0x06, 0x4f, + 0x54, 0x48, 0x45, 0x52, 0x33, 0x10, 0x09, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x41, 0x43, 0x5f, 0x31, + 0x36, 0x30, 0x10, 0x0a, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x41, 0x43, 0x5f, 0x33, 0x32, 0x30, 0x10, + 0x0b, 0x4a, 0xa2, 0x39, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xa2, 0x01, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, + 0x00, 0x05, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, 0x11, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x03, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x03, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x03, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x04, 0x04, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x04, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x04, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x04, 0x13, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x04, 0x1b, 0x1e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x07, 0x00, 0x0b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x07, 0x08, + 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x08, 0x04, 0x25, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x08, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x08, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x08, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x08, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, + 0x09, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x09, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x09, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x09, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x09, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x02, 0x12, 0x03, 0x0a, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x0a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, + 0x03, 0x0a, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0a, + 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0a, 0x1d, 0x20, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x0d, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x0e, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x0e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0e, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x13, 0x16, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x19, 0x1c, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x0f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x0f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x0f, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0f, + 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x10, 0x04, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, 0x03, 0x10, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x10, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x10, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x10, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x11, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x12, 0x03, 0x11, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x06, 0x12, 0x03, 0x11, 0x0d, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x11, 0x17, 0x20, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, 0x03, 0x11, 0x23, 0x26, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x12, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x04, 0x04, 0x12, 0x03, 0x12, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x06, + 0x12, 0x03, 0x12, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x12, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x03, 0x12, 0x03, 0x12, 0x26, + 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x13, 0x04, 0x2b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x04, 0x12, 0x03, 0x13, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x05, 0x06, 0x12, 0x03, 0x13, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x05, 0x01, 0x12, 0x03, 0x13, 0x18, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, + 0x03, 0x12, 0x03, 0x13, 0x27, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x14, 0x04, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x04, 0x12, 0x03, 0x14, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x06, 0x12, 0x03, 0x14, 0x0d, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x01, 0x12, 0x03, 0x14, 0x18, 0x29, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x06, 0x03, 0x12, 0x03, 0x14, 0x2c, 0x2f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x07, 0x12, 0x03, 0x15, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, + 0x04, 0x12, 0x03, 0x15, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x06, 0x12, + 0x03, 0x15, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x01, 0x12, 0x03, 0x15, + 0x18, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x03, 0x12, 0x03, 0x15, 0x2b, 0x2e, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x08, 0x12, 0x03, 0x16, 0x04, 0x20, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x08, 0x04, 0x12, 0x03, 0x16, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x08, 0x05, 0x12, 0x03, 0x16, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x08, 0x01, 0x12, 0x03, 0x16, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x08, 0x03, + 0x12, 0x03, 0x16, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x09, 0x12, 0x03, 0x17, + 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x09, 0x04, 0x12, 0x03, 0x17, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x09, 0x06, 0x12, 0x03, 0x17, 0x0d, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x09, 0x01, 0x12, 0x03, 0x17, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x09, 0x03, 0x12, 0x03, 0x17, 0x26, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x0a, 0x12, 0x03, 0x18, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0a, 0x04, + 0x12, 0x03, 0x18, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0a, 0x06, 0x12, 0x03, + 0x18, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x18, 0x13, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x18, 0x1e, 0x21, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x0b, 0x12, 0x03, 0x19, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x0b, 0x04, 0x12, 0x03, 0x19, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x0b, 0x06, 0x12, 0x03, 0x19, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0b, + 0x01, 0x12, 0x03, 0x19, 0x17, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0b, 0x03, 0x12, + 0x03, 0x19, 0x23, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x0c, 0x12, 0x03, 0x1a, 0x04, + 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0c, 0x04, 0x12, 0x03, 0x1a, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0c, 0x06, 0x12, 0x03, 0x1a, 0x0d, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x1a, 0x1c, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x1a, 0x2e, 0x31, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, + 0x0d, 0x12, 0x03, 0x1b, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0d, 0x04, 0x12, + 0x03, 0x1b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0d, 0x06, 0x12, 0x03, 0x1b, + 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x1b, 0x19, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x1b, 0x27, 0x2a, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x0e, 0x12, 0x03, 0x1c, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x0e, 0x04, 0x12, 0x03, 0x1c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x0e, 0x06, 0x12, 0x03, 0x1c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0e, 0x01, + 0x12, 0x03, 0x1c, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0e, 0x03, 0x12, 0x03, + 0x1c, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x0f, 0x12, 0x03, 0x1d, 0x04, 0x31, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0f, 0x04, 0x12, 0x03, 0x1d, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x0f, 0x05, 0x12, 0x03, 0x1d, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x1d, 0x12, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x0f, 0x03, 0x12, 0x03, 0x1d, 0x2c, 0x30, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x10, + 0x12, 0x03, 0x1e, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x10, 0x04, 0x12, 0x03, + 0x1e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x10, 0x06, 0x12, 0x03, 0x1e, 0x0d, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x10, 0x01, 0x12, 0x03, 0x1e, 0x18, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x10, 0x03, 0x12, 0x03, 0x1e, 0x29, 0x2d, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x21, 0x00, 0x23, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, + 0x12, 0x03, 0x21, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x22, + 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x22, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x22, 0x0d, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x13, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x1b, 0x1e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, + 0x12, 0x04, 0x25, 0x00, 0x29, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x25, + 0x08, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x26, 0x04, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, 0x26, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x26, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x26, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x26, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x27, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x04, 0x12, 0x03, 0x27, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x27, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x27, 0x14, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x27, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x28, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x28, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, + 0x12, 0x03, 0x28, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x28, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x28, 0x1a, + 0x1d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x2b, 0x00, 0x42, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x2b, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x2c, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x2c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2c, + 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2c, 0x13, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2c, 0x19, 0x1c, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x2d, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x04, 0x12, 0x03, 0x2d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x2d, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x2d, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2d, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x2e, 0x04, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x03, 0x2e, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2e, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x2e, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, + 0x12, 0x03, 0x2f, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x04, 0x12, 0x03, + 0x2f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x06, 0x12, 0x03, 0x2f, 0x0d, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x03, 0x2f, 0x12, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x03, 0x2f, 0x18, 0x1b, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x05, 0x04, 0x00, 0x12, 0x04, 0x30, 0x04, 0x34, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x04, 0x00, 0x01, 0x12, 0x03, 0x30, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x31, 0x08, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x31, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x03, 0x31, 0x10, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x32, 0x08, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x32, 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x03, 0x32, 0x11, 0x14, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x33, 0x08, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x33, 0x08, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x33, 0x16, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x03, + 0x35, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x04, 0x12, 0x03, 0x35, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x05, 0x12, 0x03, 0x35, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x03, 0x35, 0x14, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x03, 0x35, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x05, 0x12, 0x03, 0x36, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, + 0x04, 0x12, 0x03, 0x36, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x06, 0x12, + 0x03, 0x36, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x01, 0x12, 0x03, 0x36, + 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, 0x12, 0x03, 0x36, 0x19, 0x1c, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, 0x03, 0x37, 0x04, 0x25, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x06, 0x04, 0x12, 0x03, 0x37, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x06, 0x05, 0x12, 0x03, 0x37, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x06, 0x01, 0x12, 0x03, 0x37, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, + 0x12, 0x03, 0x37, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x03, 0x38, + 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x04, 0x12, 0x03, 0x38, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x05, 0x12, 0x03, 0x38, 0x0d, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x03, 0x38, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x03, 0x38, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x08, 0x12, 0x03, 0x39, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x04, + 0x12, 0x03, 0x39, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x06, 0x12, 0x03, + 0x39, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x01, 0x12, 0x03, 0x39, 0x13, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x03, 0x12, 0x03, 0x39, 0x1b, 0x1e, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x09, 0x12, 0x03, 0x3a, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x09, 0x04, 0x12, 0x03, 0x3a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x09, 0x06, 0x12, 0x03, 0x3a, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x09, + 0x01, 0x12, 0x03, 0x3a, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x09, 0x03, 0x12, + 0x03, 0x3a, 0x26, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0a, 0x12, 0x03, 0x3b, 0x04, + 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x04, 0x12, 0x03, 0x3b, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x3b, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x3b, 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x3b, 0x19, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x0b, 0x12, 0x03, 0x3c, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x04, 0x12, + 0x03, 0x3c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x05, 0x12, 0x03, 0x3c, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x3c, 0x14, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x3c, 0x1d, 0x20, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0c, 0x12, 0x03, 0x3d, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x0c, 0x04, 0x12, 0x03, 0x3d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x0c, 0x06, 0x12, 0x03, 0x3d, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0c, 0x01, + 0x12, 0x03, 0x3d, 0x17, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0c, 0x03, 0x12, 0x03, + 0x3d, 0x23, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0d, 0x12, 0x03, 0x3e, 0x04, 0x2b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0d, 0x04, 0x12, 0x03, 0x3e, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0d, 0x06, 0x12, 0x03, 0x3e, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x3e, 0x19, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x0d, 0x03, 0x12, 0x03, 0x3e, 0x27, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0e, + 0x12, 0x03, 0x3f, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x04, 0x12, 0x03, + 0x3f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x3f, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x3f, 0x13, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x03, 0x12, 0x03, 0x3f, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x0f, 0x12, 0x03, 0x40, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x0f, 0x04, 0x12, 0x03, 0x40, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, + 0x06, 0x12, 0x03, 0x40, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x01, 0x12, + 0x03, 0x40, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x03, 0x12, 0x03, 0x40, + 0x26, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x10, 0x12, 0x03, 0x41, 0x04, 0x2b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x10, 0x04, 0x12, 0x03, 0x41, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x10, 0x06, 0x12, 0x03, 0x41, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x10, 0x01, 0x12, 0x03, 0x41, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x10, 0x03, 0x12, 0x03, 0x41, 0x26, 0x2a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x44, + 0x00, 0x54, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x44, 0x08, 0x0d, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x45, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x03, 0x45, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x45, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x45, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x45, 0x19, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x46, 0x04, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, 0x12, 0x03, 0x46, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x03, 0x46, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x46, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x46, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x02, 0x12, 0x03, 0x47, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x47, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x03, 0x47, + 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x47, 0x13, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x47, 0x1b, 0x1e, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x48, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x03, 0x04, 0x12, 0x03, 0x48, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x03, 0x06, 0x12, 0x03, 0x48, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x48, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x48, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x04, 0x12, 0x03, 0x49, 0x04, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, 0x03, 0x49, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x05, 0x12, 0x03, 0x49, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x03, 0x49, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x49, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x05, + 0x12, 0x03, 0x4a, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x04, 0x12, 0x03, + 0x4a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x05, 0x12, 0x03, 0x4a, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, 0x12, 0x03, 0x4a, 0x14, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x03, 0x4a, 0x22, 0x25, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x06, 0x12, 0x03, 0x4b, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x06, 0x04, 0x12, 0x03, 0x4b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, + 0x05, 0x12, 0x03, 0x4b, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x01, 0x12, + 0x03, 0x4b, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x03, 0x12, 0x03, 0x4b, + 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x07, 0x12, 0x03, 0x4c, 0x04, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x04, 0x12, 0x03, 0x4c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x07, 0x05, 0x12, 0x03, 0x4c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x07, 0x01, 0x12, 0x03, 0x4c, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x07, 0x03, 0x12, 0x03, 0x4c, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x08, 0x12, + 0x03, 0x4d, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x04, 0x12, 0x03, 0x4d, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x05, 0x12, 0x03, 0x4d, 0x0d, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x01, 0x12, 0x03, 0x4d, 0x12, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x03, 0x12, 0x03, 0x4d, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x09, 0x12, 0x03, 0x4e, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x09, 0x04, 0x12, 0x03, 0x4e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x09, 0x06, + 0x12, 0x03, 0x4e, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x09, 0x01, 0x12, 0x03, + 0x4e, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x09, 0x03, 0x12, 0x03, 0x4e, 0x26, + 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0a, 0x12, 0x03, 0x4f, 0x04, 0x2b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0a, 0x04, 0x12, 0x03, 0x4f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x4f, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x0a, 0x01, 0x12, 0x03, 0x4f, 0x19, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0a, + 0x03, 0x12, 0x03, 0x4f, 0x27, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0b, 0x12, 0x03, + 0x50, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, 0x04, 0x12, 0x03, 0x50, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, 0x06, 0x12, 0x03, 0x50, 0x0d, 0x16, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x50, 0x17, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x50, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x06, 0x02, 0x0c, 0x12, 0x03, 0x51, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0c, + 0x04, 0x12, 0x03, 0x51, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0c, 0x06, 0x12, + 0x03, 0x51, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x51, + 0x13, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x51, 0x21, 0x24, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0d, 0x12, 0x03, 0x52, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x0d, 0x04, 0x12, 0x03, 0x52, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x0d, 0x06, 0x12, 0x03, 0x52, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x0d, 0x01, 0x12, 0x03, 0x52, 0x18, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0d, 0x03, + 0x12, 0x03, 0x52, 0x26, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0e, 0x12, 0x03, 0x53, + 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0e, 0x04, 0x12, 0x03, 0x53, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x53, 0x0d, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x53, 0x17, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x0e, 0x03, 0x12, 0x03, 0x53, 0x21, 0x24, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, + 0x12, 0x04, 0x56, 0x00, 0x61, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x56, + 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x57, 0x04, 0x21, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x03, 0x57, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x03, 0x57, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x57, 0x13, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x57, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, + 0x03, 0x58, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x04, 0x12, 0x03, 0x58, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, 0x03, 0x58, 0x0d, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x58, 0x12, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x58, 0x19, 0x1c, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x07, 0x04, 0x00, 0x12, 0x04, 0x59, 0x04, 0x5e, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x59, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x07, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x5a, 0x08, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x5a, 0x08, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x5a, 0x12, 0x15, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x07, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x5b, 0x08, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x5b, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x5b, 0x10, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x07, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x5c, 0x08, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x5c, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x5c, 0x10, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x07, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x5d, 0x08, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x5d, 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x5d, 0x11, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x5f, 0x04, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x04, 0x12, 0x03, 0x5f, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x05, 0x12, 0x03, 0x5f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, 0x12, 0x03, 0x5f, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x02, 0x03, 0x12, 0x03, 0x5f, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, + 0x03, 0x12, 0x03, 0x60, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x04, 0x12, + 0x03, 0x60, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x05, 0x12, 0x03, 0x60, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x01, 0x12, 0x03, 0x60, 0x14, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x03, 0x12, 0x03, 0x60, 0x1d, 0x20, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x63, 0x00, 0x65, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, + 0x01, 0x12, 0x03, 0x63, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, + 0x64, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x64, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x03, 0x64, 0x0d, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x64, 0x13, 0x18, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x64, 0x1b, 0x1e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x09, 0x12, 0x04, 0x67, 0x00, 0x6b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, + 0x67, 0x08, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x68, 0x04, 0x1f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x03, 0x68, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x03, 0x68, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x68, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x68, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, + 0x12, 0x03, 0x69, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12, 0x03, + 0x69, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x03, 0x69, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x69, 0x13, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x69, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x03, 0x6a, 0x04, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x02, 0x04, 0x12, 0x03, 0x6a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x6a, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x6a, 0x18, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x03, 0x6a, + 0x29, 0x2c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x6d, 0x00, 0x71, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x6d, 0x08, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x00, 0x12, 0x03, 0x6e, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x6e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x6e, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6e, 0x14, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6e, 0x1d, 0x20, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x6f, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x03, 0x6f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x6f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x6f, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x6f, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x03, 0x70, 0x04, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x04, 0x12, 0x03, 0x70, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x06, 0x12, 0x03, 0x70, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x03, 0x70, 0x13, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x02, 0x03, 0x12, 0x03, 0x70, 0x1b, 0x1e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0b, 0x12, + 0x04, 0x73, 0x00, 0x7a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x03, 0x73, 0x08, + 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x03, 0x74, 0x04, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, 0x03, 0x74, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, 0x03, 0x74, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x74, 0x12, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x74, 0x18, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x04, 0x00, 0x12, 0x04, + 0x75, 0x04, 0x78, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x04, 0x00, 0x01, 0x12, 0x03, 0x75, + 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x76, 0x08, + 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x76, 0x08, + 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x76, 0x0c, + 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x77, 0x08, 0x10, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x77, 0x08, 0x09, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x0b, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x77, 0x0c, 0x0f, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x03, 0x79, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x01, 0x04, 0x12, 0x03, 0x79, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x01, 0x05, 0x12, 0x03, 0x79, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x79, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x79, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x05, 0x7c, 0x00, 0x84, + 0x01, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x03, 0x7c, 0x08, 0x13, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x03, 0x7d, 0x04, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x00, 0x04, 0x12, 0x03, 0x7d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x7d, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x7d, 0x14, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x7d, 0x28, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x03, 0x7e, 0x04, 0x2e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x04, 0x12, 0x03, 0x7e, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x05, 0x12, 0x03, 0x7e, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7e, 0x14, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x7e, 0x2a, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x02, + 0x12, 0x03, 0x7f, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x04, 0x12, 0x03, + 0x7f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x06, 0x12, 0x03, 0x7f, 0x0d, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x01, 0x12, 0x03, 0x7f, 0x12, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x03, 0x12, 0x03, 0x7f, 0x18, 0x1b, 0x0a, 0x0e, 0x0a, + 0x04, 0x04, 0x0c, 0x04, 0x00, 0x12, 0x06, 0x80, 0x01, 0x04, 0x82, 0x01, 0x05, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x04, 0x00, 0x01, 0x12, 0x04, 0x80, 0x01, 0x09, 0x0d, 0x0a, 0x0e, 0x0a, 0x06, + 0x04, 0x0c, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0x81, 0x01, 0x08, 0x18, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x0c, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0x81, 0x01, 0x08, 0x11, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0x81, 0x01, 0x14, 0x17, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x03, 0x12, 0x04, 0x83, 0x01, 0x04, 0x28, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x03, 0x04, 0x12, 0x04, 0x83, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x03, 0x05, 0x12, 0x04, 0x83, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x03, 0x01, 0x12, 0x04, 0x83, 0x01, 0x14, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x03, 0x03, 0x12, 0x04, 0x83, 0x01, 0x24, 0x27, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, + 0x86, 0x01, 0x00, 0x8a, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0x86, + 0x01, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0x87, 0x01, 0x04, + 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0x87, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0x87, 0x01, 0x0d, 0x18, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0x87, 0x01, 0x19, 0x24, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x87, 0x01, 0x27, 0x2a, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0x88, 0x01, 0x04, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x01, 0x04, 0x12, 0x04, 0x88, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x01, 0x06, 0x12, 0x04, 0x88, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, + 0x01, 0x01, 0x12, 0x04, 0x88, 0x01, 0x12, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, + 0x03, 0x12, 0x04, 0x88, 0x01, 0x1a, 0x1d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x02, 0x12, + 0x04, 0x89, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x04, 0x12, 0x04, + 0x89, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x06, 0x12, 0x04, 0x89, + 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x01, 0x12, 0x04, 0x89, 0x01, + 0x12, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x03, 0x12, 0x04, 0x89, 0x01, 0x18, + 0x1b, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0x8c, 0x01, 0x00, 0x8f, 0x01, 0x01, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x8d, 0x01, 0x04, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x00, 0x04, 0x12, 0x04, 0x8d, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x00, 0x05, 0x12, 0x04, 0x8d, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x8d, 0x01, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x8d, 0x01, 0x1a, 0x1d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, + 0x8e, 0x01, 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8e, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8e, 0x01, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x14, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x19, 0x1c, + 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, 0x91, 0x01, 0x00, 0xa2, 0x01, 0x01, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0x91, 0x01, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x0f, 0x02, 0x00, 0x12, 0x04, 0x92, 0x01, 0x04, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x00, 0x04, 0x12, 0x04, 0x92, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, + 0x05, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, + 0x12, 0x04, 0x92, 0x01, 0x13, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, + 0x04, 0x92, 0x01, 0x1d, 0x20, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0x93, + 0x01, 0x04, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x04, 0x12, 0x04, 0x93, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x06, 0x12, 0x04, 0x93, 0x01, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, 0x93, 0x01, 0x14, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, 0x93, 0x01, 0x1d, 0x20, 0x0a, + 0x0e, 0x0a, 0x04, 0x04, 0x0f, 0x04, 0x00, 0x12, 0x06, 0x94, 0x01, 0x04, 0xa1, 0x01, 0x05, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x04, 0x00, 0x01, 0x12, 0x04, 0x94, 0x01, 0x09, 0x0f, 0x0a, 0x0e, + 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0x95, 0x01, 0x08, 0x1c, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0x95, 0x01, 0x08, 0x15, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0x95, 0x01, 0x18, 0x1b, + 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0x96, 0x01, 0x08, 0x1d, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0x96, 0x01, 0x08, + 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0x96, 0x01, + 0x19, 0x1c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0x97, 0x01, + 0x08, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0x97, + 0x01, 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, + 0x97, 0x01, 0x19, 0x1c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x03, 0x12, 0x04, + 0x98, 0x01, 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x04, 0x98, 0x01, 0x08, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x03, 0x02, + 0x12, 0x04, 0x98, 0x01, 0x12, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x04, + 0x12, 0x04, 0x99, 0x01, 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x99, 0x01, 0x08, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, + 0x04, 0x02, 0x12, 0x04, 0x99, 0x01, 0x12, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, + 0x02, 0x05, 0x12, 0x04, 0x9a, 0x01, 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, + 0x02, 0x05, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x08, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, + 0x00, 0x02, 0x05, 0x02, 0x12, 0x04, 0x9a, 0x01, 0x12, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, + 0x04, 0x00, 0x02, 0x06, 0x12, 0x04, 0x9b, 0x01, 0x08, 0x15, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, + 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x08, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0f, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x04, 0x9b, 0x01, 0x11, 0x14, 0x0a, 0x0e, 0x0a, 0x06, + 0x04, 0x0f, 0x04, 0x00, 0x02, 0x07, 0x12, 0x04, 0x9c, 0x01, 0x08, 0x1a, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x0f, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9c, 0x01, 0x08, 0x13, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x04, 0x9c, 0x01, 0x16, 0x19, 0x0a, 0x0e, + 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x08, 0x12, 0x04, 0x9d, 0x01, 0x08, 0x15, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9d, 0x01, 0x08, 0x0e, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x08, 0x02, 0x12, 0x04, 0x9d, 0x01, 0x11, 0x14, + 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x09, 0x12, 0x04, 0x9e, 0x01, 0x08, 0x15, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x08, + 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x09, 0x02, 0x12, 0x04, 0x9e, 0x01, + 0x11, 0x14, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x04, 0x9f, 0x01, + 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x04, 0x9f, + 0x01, 0x08, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x04, + 0x9f, 0x01, 0x12, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0b, 0x12, 0x04, + 0xa0, 0x01, 0x08, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0b, 0x01, 0x12, + 0x04, 0xa0, 0x01, 0x08, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x04, 0x00, 0x02, 0x0b, 0x02, + 0x12, 0x04, 0xa0, 0x01, 0x12, 0x15, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/protocol/src/pubsub.rs b/protocol/src/pubsub.rs new file mode 100644 index 00000000..8227f892 --- /dev/null +++ b/protocol/src/pubsub.rs @@ -0,0 +1,329 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct Subscription { + // message fields + uri: ::protobuf::SingularField<::std::string::String>, + expiry: ::std::option::Option, + status_code: ::std::option::Option, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Subscription {} + +impl Subscription { + pub fn new() -> Subscription { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Subscription { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Subscription, + }; + unsafe { + instance.get(|| { + Subscription { + uri: ::protobuf::SingularField::none(), + expiry: ::std::option::Option::None, + status_code: ::std::option::Option::None, + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string uri = 1; + + pub fn clear_uri(&mut self) { + self.uri.clear(); + } + + pub fn has_uri(&self) -> bool { + self.uri.is_some() + } + + // Param is passed by value, moved + pub fn set_uri(&mut self, v: ::std::string::String) { + self.uri = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_uri(&mut self) -> &mut ::std::string::String { + if self.uri.is_none() { + self.uri.set_default(); + }; + self.uri.as_mut().unwrap() + } + + // Take field + pub fn take_uri(&mut self) -> ::std::string::String { + self.uri.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_uri(&self) -> &str { + match self.uri.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional int32 expiry = 2; + + pub fn clear_expiry(&mut self) { + self.expiry = ::std::option::Option::None; + } + + pub fn has_expiry(&self) -> bool { + self.expiry.is_some() + } + + // Param is passed by value, moved + pub fn set_expiry(&mut self, v: i32) { + self.expiry = ::std::option::Option::Some(v); + } + + pub fn get_expiry(&self) -> i32 { + self.expiry.unwrap_or(0) + } + + // optional int32 status_code = 3; + + pub fn clear_status_code(&mut self) { + self.status_code = ::std::option::Option::None; + } + + pub fn has_status_code(&self) -> bool { + self.status_code.is_some() + } + + // Param is passed by value, moved + pub fn set_status_code(&mut self, v: i32) { + self.status_code = ::std::option::Option::Some(v); + } + + pub fn get_status_code(&self) -> i32 { + self.status_code.unwrap_or(0) + } +} + +impl ::protobuf::Message for Subscription { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.expiry = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.status_code = ::std::option::Option::Some(tmp); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.uri { + my_size += ::protobuf::rt::string_size(1, &value); + }; + for value in &self.expiry { + my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.status_code { + my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.uri.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.expiry { + try!(os.write_int32(2, v)); + }; + if let Some(v) = self.status_code { + try!(os.write_int32(3, v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Subscription { + fn new() -> Subscription { + Subscription::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "uri", + Subscription::has_uri, + Subscription::get_uri, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "expiry", + Subscription::has_expiry, + Subscription::get_expiry, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "status_code", + Subscription::has_status_code, + Subscription::get_status_code, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Subscription", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Subscription { + fn clear(&mut self) { + self.clear_uri(); + self.clear_expiry(); + self.clear_status_code(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Subscription { + fn eq(&self, other: &Subscription) -> bool { + self.uri == other.uri && + self.expiry == other.expiry && + self.status_code == other.status_code && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Subscription { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x0c, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x59, + 0x0a, 0x0c, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, + 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, + 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x4a, 0xf9, 0x01, 0x0a, 0x06, 0x12, 0x04, + 0x00, 0x00, 0x06, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, 0x00, 0x06, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x02, 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x03, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x03, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x03, 0x14, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x03, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x04, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x04, 0x12, 0x03, 0x04, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x04, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x04, + 0x13, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x04, 0x1c, 0x1f, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x05, 0x04, 0x25, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x05, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x05, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x05, 0x13, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x05, 0x21, 0x24, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/protocol/src/spirc.rs b/protocol/src/spirc.rs new file mode 100644 index 00000000..ebd20b1c --- /dev/null +++ b/protocol/src/spirc.rs @@ -0,0 +1,4262 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(Clone,Default)] +pub struct Frame { + // message fields + version: ::std::option::Option, + ident: ::protobuf::SingularField<::std::string::String>, + protocol_version: ::protobuf::SingularField<::std::string::String>, + seq_nr: ::std::option::Option, + typ: ::std::option::Option, + device_state: ::protobuf::SingularPtrField, + goodbye: ::protobuf::SingularPtrField, + state: ::protobuf::SingularPtrField, + position: ::std::option::Option, + volume: ::std::option::Option, + state_update_id: ::std::option::Option, + recipient: ::protobuf::RepeatedField<::std::string::String>, + context_player_state: ::protobuf::SingularField<::std::vec::Vec>, + new_name: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Frame {} + +impl Frame { + pub fn new() -> Frame { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Frame { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Frame, + }; + unsafe { + instance.get(|| { + Frame { + version: ::std::option::Option::None, + ident: ::protobuf::SingularField::none(), + protocol_version: ::protobuf::SingularField::none(), + seq_nr: ::std::option::Option::None, + typ: ::std::option::Option::None, + device_state: ::protobuf::SingularPtrField::none(), + goodbye: ::protobuf::SingularPtrField::none(), + state: ::protobuf::SingularPtrField::none(), + position: ::std::option::Option::None, + volume: ::std::option::Option::None, + state_update_id: ::std::option::Option::None, + recipient: ::protobuf::RepeatedField::new(), + context_player_state: ::protobuf::SingularField::none(), + new_name: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional uint32 version = 1; + + pub fn clear_version(&mut self) { + self.version = ::std::option::Option::None; + } + + pub fn has_version(&self) -> bool { + self.version.is_some() + } + + // Param is passed by value, moved + pub fn set_version(&mut self, v: u32) { + self.version = ::std::option::Option::Some(v); + } + + pub fn get_version(&self) -> u32 { + self.version.unwrap_or(0) + } + + // optional string ident = 2; + + pub fn clear_ident(&mut self) { + self.ident.clear(); + } + + pub fn has_ident(&self) -> bool { + self.ident.is_some() + } + + // Param is passed by value, moved + pub fn set_ident(&mut self, v: ::std::string::String) { + self.ident = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ident(&mut self) -> &mut ::std::string::String { + if self.ident.is_none() { + self.ident.set_default(); + }; + self.ident.as_mut().unwrap() + } + + // Take field + pub fn take_ident(&mut self) -> ::std::string::String { + self.ident.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_ident(&self) -> &str { + match self.ident.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string protocol_version = 3; + + pub fn clear_protocol_version(&mut self) { + self.protocol_version.clear(); + } + + pub fn has_protocol_version(&self) -> bool { + self.protocol_version.is_some() + } + + // Param is passed by value, moved + pub fn set_protocol_version(&mut self, v: ::std::string::String) { + self.protocol_version = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_protocol_version(&mut self) -> &mut ::std::string::String { + if self.protocol_version.is_none() { + self.protocol_version.set_default(); + }; + self.protocol_version.as_mut().unwrap() + } + + // Take field + pub fn take_protocol_version(&mut self) -> ::std::string::String { + self.protocol_version.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_protocol_version(&self) -> &str { + match self.protocol_version.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional uint32 seq_nr = 4; + + pub fn clear_seq_nr(&mut self) { + self.seq_nr = ::std::option::Option::None; + } + + pub fn has_seq_nr(&self) -> bool { + self.seq_nr.is_some() + } + + // Param is passed by value, moved + pub fn set_seq_nr(&mut self, v: u32) { + self.seq_nr = ::std::option::Option::Some(v); + } + + pub fn get_seq_nr(&self) -> u32 { + self.seq_nr.unwrap_or(0) + } + + // optional .MessageType typ = 5; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: MessageType) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> MessageType { + self.typ.unwrap_or(MessageType::kMessageTypeHello) + } + + // optional .DeviceState device_state = 7; + + pub fn clear_device_state(&mut self) { + self.device_state.clear(); + } + + pub fn has_device_state(&self) -> bool { + self.device_state.is_some() + } + + // Param is passed by value, moved + pub fn set_device_state(&mut self, v: DeviceState) { + self.device_state = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_device_state(&mut self) -> &mut DeviceState { + if self.device_state.is_none() { + self.device_state.set_default(); + }; + self.device_state.as_mut().unwrap() + } + + // Take field + pub fn take_device_state(&mut self) -> DeviceState { + self.device_state.take().unwrap_or_else(|| DeviceState::new()) + } + + pub fn get_device_state(&self) -> &DeviceState { + self.device_state.as_ref().unwrap_or_else(|| DeviceState::default_instance()) + } + + // optional .Goodbye goodbye = 11; + + pub fn clear_goodbye(&mut self) { + self.goodbye.clear(); + } + + pub fn has_goodbye(&self) -> bool { + self.goodbye.is_some() + } + + // Param is passed by value, moved + pub fn set_goodbye(&mut self, v: Goodbye) { + self.goodbye = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_goodbye(&mut self) -> &mut Goodbye { + if self.goodbye.is_none() { + self.goodbye.set_default(); + }; + self.goodbye.as_mut().unwrap() + } + + // Take field + pub fn take_goodbye(&mut self) -> Goodbye { + self.goodbye.take().unwrap_or_else(|| Goodbye::new()) + } + + pub fn get_goodbye(&self) -> &Goodbye { + self.goodbye.as_ref().unwrap_or_else(|| Goodbye::default_instance()) + } + + // optional .State state = 12; + + pub fn clear_state(&mut self) { + self.state.clear(); + } + + pub fn has_state(&self) -> bool { + self.state.is_some() + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: State) { + self.state = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_state(&mut self) -> &mut State { + if self.state.is_none() { + self.state.set_default(); + }; + self.state.as_mut().unwrap() + } + + // Take field + pub fn take_state(&mut self) -> State { + self.state.take().unwrap_or_else(|| State::new()) + } + + pub fn get_state(&self) -> &State { + self.state.as_ref().unwrap_or_else(|| State::default_instance()) + } + + // optional uint32 position = 13; + + pub fn clear_position(&mut self) { + self.position = ::std::option::Option::None; + } + + pub fn has_position(&self) -> bool { + self.position.is_some() + } + + // Param is passed by value, moved + pub fn set_position(&mut self, v: u32) { + self.position = ::std::option::Option::Some(v); + } + + pub fn get_position(&self) -> u32 { + self.position.unwrap_or(0) + } + + // optional uint32 volume = 14; + + pub fn clear_volume(&mut self) { + self.volume = ::std::option::Option::None; + } + + pub fn has_volume(&self) -> bool { + self.volume.is_some() + } + + // Param is passed by value, moved + pub fn set_volume(&mut self, v: u32) { + self.volume = ::std::option::Option::Some(v); + } + + pub fn get_volume(&self) -> u32 { + self.volume.unwrap_or(0) + } + + // optional int64 state_update_id = 17; + + pub fn clear_state_update_id(&mut self) { + self.state_update_id = ::std::option::Option::None; + } + + pub fn has_state_update_id(&self) -> bool { + self.state_update_id.is_some() + } + + // Param is passed by value, moved + pub fn set_state_update_id(&mut self, v: i64) { + self.state_update_id = ::std::option::Option::Some(v); + } + + pub fn get_state_update_id(&self) -> i64 { + self.state_update_id.unwrap_or(0) + } + + // repeated string recipient = 18; + + pub fn clear_recipient(&mut self) { + self.recipient.clear(); + } + + // Param is passed by value, moved + pub fn set_recipient(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.recipient = v; + } + + // Mutable pointer to the field. + pub fn mut_recipient(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.recipient + } + + // Take field + pub fn take_recipient(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.recipient, ::protobuf::RepeatedField::new()) + } + + pub fn get_recipient(&self) -> &[::std::string::String] { + &self.recipient + } + + // optional bytes context_player_state = 19; + + pub fn clear_context_player_state(&mut self) { + self.context_player_state.clear(); + } + + pub fn has_context_player_state(&self) -> bool { + self.context_player_state.is_some() + } + + // Param is passed by value, moved + pub fn set_context_player_state(&mut self, v: ::std::vec::Vec) { + self.context_player_state = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_context_player_state(&mut self) -> &mut ::std::vec::Vec { + if self.context_player_state.is_none() { + self.context_player_state.set_default(); + }; + self.context_player_state.as_mut().unwrap() + } + + // Take field + pub fn take_context_player_state(&mut self) -> ::std::vec::Vec { + self.context_player_state.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_context_player_state(&self) -> &[u8] { + match self.context_player_state.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string new_name = 20; + + pub fn clear_new_name(&mut self) { + self.new_name.clear(); + } + + pub fn has_new_name(&self) -> bool { + self.new_name.is_some() + } + + // Param is passed by value, moved + pub fn set_new_name(&mut self, v: ::std::string::String) { + self.new_name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_new_name(&mut self) -> &mut ::std::string::String { + if self.new_name.is_none() { + self.new_name.set_default(); + }; + self.new_name.as_mut().unwrap() + } + + // Take field + pub fn take_new_name(&mut self) -> ::std::string::String { + self.new_name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_new_name(&self) -> &str { + match self.new_name.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for Frame { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.version = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ident)); + }, + 3 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.protocol_version)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.seq_nr = ::std::option::Option::Some(tmp); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 7 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.device_state)); + }, + 11 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.goodbye)); + }, + 12 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.state)); + }, + 13 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.position = ::std::option::Option::Some(tmp); + }, + 14 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.volume = ::std::option::Option::Some(tmp); + }, + 17 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int64()); + self.state_update_id = ::std::option::Option::Some(tmp); + }, + 18 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.recipient)); + }, + 19 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.context_player_state)); + }, + 20 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.new_name)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.version { + my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.ident { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.protocol_version { + my_size += ::protobuf::rt::string_size(3, &value); + }; + for value in &self.seq_nr { + my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(5, *value); + }; + for value in &self.device_state { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.goodbye { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.state { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.position { + my_size += ::protobuf::rt::value_size(13, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.volume { + my_size += ::protobuf::rt::value_size(14, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.state_update_id { + my_size += ::protobuf::rt::value_size(17, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.recipient { + my_size += ::protobuf::rt::string_size(18, &value); + }; + for value in &self.context_player_state { + my_size += ::protobuf::rt::bytes_size(19, &value); + }; + for value in &self.new_name { + my_size += ::protobuf::rt::string_size(20, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.version { + try!(os.write_uint32(1, v)); + }; + if let Some(v) = self.ident.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.protocol_version.as_ref() { + try!(os.write_string(3, &v)); + }; + if let Some(v) = self.seq_nr { + try!(os.write_uint32(4, v)); + }; + if let Some(v) = self.typ { + try!(os.write_enum(5, v.value())); + }; + if let Some(v) = self.device_state.as_ref() { + try!(os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.goodbye.as_ref() { + try!(os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.state.as_ref() { + try!(os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.position { + try!(os.write_uint32(13, v)); + }; + if let Some(v) = self.volume { + try!(os.write_uint32(14, v)); + }; + if let Some(v) = self.state_update_id { + try!(os.write_int64(17, v)); + }; + for v in &self.recipient { + try!(os.write_string(18, &v)); + }; + if let Some(v) = self.context_player_state.as_ref() { + try!(os.write_bytes(19, &v)); + }; + if let Some(v) = self.new_name.as_ref() { + try!(os.write_string(20, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Frame { + fn new() -> Frame { + Frame::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "version", + Frame::has_version, + Frame::get_version, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "ident", + Frame::has_ident, + Frame::get_ident, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "protocol_version", + Frame::has_protocol_version, + Frame::get_protocol_version, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "seq_nr", + Frame::has_seq_nr, + Frame::get_seq_nr, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + Frame::has_typ, + Frame::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "device_state", + Frame::has_device_state, + Frame::get_device_state, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "goodbye", + Frame::has_goodbye, + Frame::get_goodbye, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "state", + Frame::has_state, + Frame::get_state, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "position", + Frame::has_position, + Frame::get_position, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "volume", + Frame::has_volume, + Frame::get_volume, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor( + "state_update_id", + Frame::has_state_update_id, + Frame::get_state_update_id, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "recipient", + Frame::get_recipient, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "context_player_state", + Frame::has_context_player_state, + Frame::get_context_player_state, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "new_name", + Frame::has_new_name, + Frame::get_new_name, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Frame", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Frame { + fn clear(&mut self) { + self.clear_version(); + self.clear_ident(); + self.clear_protocol_version(); + self.clear_seq_nr(); + self.clear_typ(); + self.clear_device_state(); + self.clear_goodbye(); + self.clear_state(); + self.clear_position(); + self.clear_volume(); + self.clear_state_update_id(); + self.clear_recipient(); + self.clear_context_player_state(); + self.clear_new_name(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Frame { + fn eq(&self, other: &Frame) -> bool { + self.version == other.version && + self.ident == other.ident && + self.protocol_version == other.protocol_version && + self.seq_nr == other.seq_nr && + self.typ == other.typ && + self.device_state == other.device_state && + self.goodbye == other.goodbye && + self.state == other.state && + self.position == other.position && + self.volume == other.volume && + self.state_update_id == other.state_update_id && + self.recipient == other.recipient && + self.context_player_state == other.context_player_state && + self.new_name == other.new_name && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Frame { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct DeviceState { + // message fields + sw_version: ::protobuf::SingularField<::std::string::String>, + is_active: ::std::option::Option, + can_play: ::std::option::Option, + volume: ::std::option::Option, + name: ::protobuf::SingularField<::std::string::String>, + error_code: ::std::option::Option, + became_active_at: ::std::option::Option, + error_message: ::protobuf::SingularField<::std::string::String>, + capabilities: ::protobuf::RepeatedField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for DeviceState {} + +impl DeviceState { + pub fn new() -> DeviceState { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static DeviceState { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeviceState, + }; + unsafe { + instance.get(|| { + DeviceState { + sw_version: ::protobuf::SingularField::none(), + is_active: ::std::option::Option::None, + can_play: ::std::option::Option::None, + volume: ::std::option::Option::None, + name: ::protobuf::SingularField::none(), + error_code: ::std::option::Option::None, + became_active_at: ::std::option::Option::None, + error_message: ::protobuf::SingularField::none(), + capabilities: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string sw_version = 1; + + pub fn clear_sw_version(&mut self) { + self.sw_version.clear(); + } + + pub fn has_sw_version(&self) -> bool { + self.sw_version.is_some() + } + + // Param is passed by value, moved + pub fn set_sw_version(&mut self, v: ::std::string::String) { + self.sw_version = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_sw_version(&mut self) -> &mut ::std::string::String { + if self.sw_version.is_none() { + self.sw_version.set_default(); + }; + self.sw_version.as_mut().unwrap() + } + + // Take field + pub fn take_sw_version(&mut self) -> ::std::string::String { + self.sw_version.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_sw_version(&self) -> &str { + match self.sw_version.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bool is_active = 10; + + pub fn clear_is_active(&mut self) { + self.is_active = ::std::option::Option::None; + } + + pub fn has_is_active(&self) -> bool { + self.is_active.is_some() + } + + // Param is passed by value, moved + pub fn set_is_active(&mut self, v: bool) { + self.is_active = ::std::option::Option::Some(v); + } + + pub fn get_is_active(&self) -> bool { + self.is_active.unwrap_or(false) + } + + // optional bool can_play = 11; + + pub fn clear_can_play(&mut self) { + self.can_play = ::std::option::Option::None; + } + + pub fn has_can_play(&self) -> bool { + self.can_play.is_some() + } + + // Param is passed by value, moved + pub fn set_can_play(&mut self, v: bool) { + self.can_play = ::std::option::Option::Some(v); + } + + pub fn get_can_play(&self) -> bool { + self.can_play.unwrap_or(false) + } + + // optional uint32 volume = 12; + + pub fn clear_volume(&mut self) { + self.volume = ::std::option::Option::None; + } + + pub fn has_volume(&self) -> bool { + self.volume.is_some() + } + + // Param is passed by value, moved + pub fn set_volume(&mut self, v: u32) { + self.volume = ::std::option::Option::Some(v); + } + + pub fn get_volume(&self) -> u32 { + self.volume.unwrap_or(0) + } + + // optional string name = 13; + + pub fn clear_name(&mut self) { + self.name.clear(); + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name.set_default(); + }; + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional uint32 error_code = 14; + + pub fn clear_error_code(&mut self) { + self.error_code = ::std::option::Option::None; + } + + pub fn has_error_code(&self) -> bool { + self.error_code.is_some() + } + + // Param is passed by value, moved + pub fn set_error_code(&mut self, v: u32) { + self.error_code = ::std::option::Option::Some(v); + } + + pub fn get_error_code(&self) -> u32 { + self.error_code.unwrap_or(0) + } + + // optional int64 became_active_at = 15; + + pub fn clear_became_active_at(&mut self) { + self.became_active_at = ::std::option::Option::None; + } + + pub fn has_became_active_at(&self) -> bool { + self.became_active_at.is_some() + } + + // Param is passed by value, moved + pub fn set_became_active_at(&mut self, v: i64) { + self.became_active_at = ::std::option::Option::Some(v); + } + + pub fn get_became_active_at(&self) -> i64 { + self.became_active_at.unwrap_or(0) + } + + // optional string error_message = 16; + + pub fn clear_error_message(&mut self) { + self.error_message.clear(); + } + + pub fn has_error_message(&self) -> bool { + self.error_message.is_some() + } + + // Param is passed by value, moved + pub fn set_error_message(&mut self, v: ::std::string::String) { + self.error_message = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_error_message(&mut self) -> &mut ::std::string::String { + if self.error_message.is_none() { + self.error_message.set_default(); + }; + self.error_message.as_mut().unwrap() + } + + // Take field + pub fn take_error_message(&mut self) -> ::std::string::String { + self.error_message.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_error_message(&self) -> &str { + match self.error_message.as_ref() { + Some(v) => &v, + None => "", + } + } + + // repeated .Capability capabilities = 17; + + pub fn clear_capabilities(&mut self) { + self.capabilities.clear(); + } + + // Param is passed by value, moved + pub fn set_capabilities(&mut self, v: ::protobuf::RepeatedField) { + self.capabilities = v; + } + + // Mutable pointer to the field. + pub fn mut_capabilities(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.capabilities + } + + // Take field + pub fn take_capabilities(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.capabilities, ::protobuf::RepeatedField::new()) + } + + pub fn get_capabilities(&self) -> &[Capability] { + &self.capabilities + } +} + +impl ::protobuf::Message for DeviceState { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sw_version)); + }, + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.is_active = ::std::option::Option::Some(tmp); + }, + 11 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.can_play = ::std::option::Option::Some(tmp); + }, + 12 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.volume = ::std::option::Option::Some(tmp); + }, + 13 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)); + }, + 14 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.error_code = ::std::option::Option::Some(tmp); + }, + 15 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int64()); + self.became_active_at = ::std::option::Option::Some(tmp); + }, + 16 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.error_message)); + }, + 17 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.capabilities)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.sw_version { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if self.is_active.is_some() { + my_size += 2; + }; + if self.can_play.is_some() { + my_size += 2; + }; + for value in &self.volume { + my_size += ::protobuf::rt::value_size(12, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.name { + my_size += ::protobuf::rt::string_size(13, &value); + }; + for value in &self.error_code { + my_size += ::protobuf::rt::value_size(14, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.became_active_at { + my_size += ::protobuf::rt::value_size(15, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.error_message { + my_size += ::protobuf::rt::string_size(16, &value); + }; + for value in &self.capabilities { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.sw_version.as_ref() { + try!(os.write_string(1, &v)); + }; + if let Some(v) = self.is_active { + try!(os.write_bool(10, v)); + }; + if let Some(v) = self.can_play { + try!(os.write_bool(11, v)); + }; + if let Some(v) = self.volume { + try!(os.write_uint32(12, v)); + }; + if let Some(v) = self.name.as_ref() { + try!(os.write_string(13, &v)); + }; + if let Some(v) = self.error_code { + try!(os.write_uint32(14, v)); + }; + if let Some(v) = self.became_active_at { + try!(os.write_int64(15, v)); + }; + if let Some(v) = self.error_message.as_ref() { + try!(os.write_string(16, &v)); + }; + for v in &self.capabilities { + try!(os.write_tag(17, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for DeviceState { + fn new() -> DeviceState { + DeviceState::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "sw_version", + DeviceState::has_sw_version, + DeviceState::get_sw_version, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "is_active", + DeviceState::has_is_active, + DeviceState::get_is_active, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "can_play", + DeviceState::has_can_play, + DeviceState::get_can_play, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "volume", + DeviceState::has_volume, + DeviceState::get_volume, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "name", + DeviceState::has_name, + DeviceState::get_name, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "error_code", + DeviceState::has_error_code, + DeviceState::get_error_code, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor( + "became_active_at", + DeviceState::has_became_active_at, + DeviceState::get_became_active_at, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "error_message", + DeviceState::has_error_message, + DeviceState::get_error_message, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "capabilities", + DeviceState::get_capabilities, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeviceState", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for DeviceState { + fn clear(&mut self) { + self.clear_sw_version(); + self.clear_is_active(); + self.clear_can_play(); + self.clear_volume(); + self.clear_name(); + self.clear_error_code(); + self.clear_became_active_at(); + self.clear_error_message(); + self.clear_capabilities(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for DeviceState { + fn eq(&self, other: &DeviceState) -> bool { + self.sw_version == other.sw_version && + self.is_active == other.is_active && + self.can_play == other.can_play && + self.volume == other.volume && + self.name == other.name && + self.error_code == other.error_code && + self.became_active_at == other.became_active_at && + self.error_message == other.error_message && + self.capabilities == other.capabilities && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for DeviceState { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Capability { + // message fields + typ: ::std::option::Option, + intValue: ::std::vec::Vec, + stringValue: ::protobuf::RepeatedField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Capability {} + +impl Capability { + pub fn new() -> Capability { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Capability { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Capability, + }; + unsafe { + instance.get(|| { + Capability { + typ: ::std::option::Option::None, + intValue: ::std::vec::Vec::new(), + stringValue: ::protobuf::RepeatedField::new(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional .CapabilityType typ = 1; + + pub fn clear_typ(&mut self) { + self.typ = ::std::option::Option::None; + } + + pub fn has_typ(&self) -> bool { + self.typ.is_some() + } + + // Param is passed by value, moved + pub fn set_typ(&mut self, v: CapabilityType) { + self.typ = ::std::option::Option::Some(v); + } + + pub fn get_typ(&self) -> CapabilityType { + self.typ.unwrap_or(CapabilityType::kSupportedContexts) + } + + // repeated int64 intValue = 2; + + pub fn clear_intValue(&mut self) { + self.intValue.clear(); + } + + // Param is passed by value, moved + pub fn set_intValue(&mut self, v: ::std::vec::Vec) { + self.intValue = v; + } + + // Mutable pointer to the field. + pub fn mut_intValue(&mut self) -> &mut ::std::vec::Vec { + &mut self.intValue + } + + // Take field + pub fn take_intValue(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.intValue, ::std::vec::Vec::new()) + } + + pub fn get_intValue(&self) -> &[i64] { + &self.intValue + } + + // repeated string stringValue = 3; + + pub fn clear_stringValue(&mut self) { + self.stringValue.clear(); + } + + // Param is passed by value, moved + pub fn set_stringValue(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.stringValue = v; + } + + // Mutable pointer to the field. + pub fn mut_stringValue(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.stringValue + } + + // Take field + pub fn take_stringValue(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.stringValue, ::protobuf::RepeatedField::new()) + } + + pub fn get_stringValue(&self) -> &[::std::string::String] { + &self.stringValue + } +} + +impl ::protobuf::Message for Capability { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.typ = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.intValue)); + }, + 3 => { + try!(::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.stringValue)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.typ { + my_size += ::protobuf::rt::enum_size(1, *value); + }; + for value in &self.intValue { + my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.stringValue { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.typ { + try!(os.write_enum(1, v.value())); + }; + for v in &self.intValue { + try!(os.write_int64(2, *v)); + }; + for v in &self.stringValue { + try!(os.write_string(3, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Capability { + fn new() -> Capability { + Capability::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "typ", + Capability::has_typ, + Capability::get_typ, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_i64_accessor( + "intValue", + Capability::get_intValue, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_string_accessor( + "stringValue", + Capability::get_stringValue, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Capability", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Capability { + fn clear(&mut self) { + self.clear_typ(); + self.clear_intValue(); + self.clear_stringValue(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Capability { + fn eq(&self, other: &Capability) -> bool { + self.typ == other.typ && + self.intValue == other.intValue && + self.stringValue == other.stringValue && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Capability { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Goodbye { + // message fields + reason: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Goodbye {} + +impl Goodbye { + pub fn new() -> Goodbye { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Goodbye { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Goodbye, + }; + unsafe { + instance.get(|| { + Goodbye { + reason: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string reason = 1; + + pub fn clear_reason(&mut self) { + self.reason.clear(); + } + + pub fn has_reason(&self) -> bool { + self.reason.is_some() + } + + // Param is passed by value, moved + pub fn set_reason(&mut self, v: ::std::string::String) { + self.reason = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_reason(&mut self) -> &mut ::std::string::String { + if self.reason.is_none() { + self.reason.set_default(); + }; + self.reason.as_mut().unwrap() + } + + // Take field + pub fn take_reason(&mut self) -> ::std::string::String { + self.reason.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_reason(&self) -> &str { + match self.reason.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for Goodbye { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.reason)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.reason { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.reason.as_ref() { + try!(os.write_string(1, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Goodbye { + fn new() -> Goodbye { + Goodbye::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "reason", + Goodbye::has_reason, + Goodbye::get_reason, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Goodbye", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Goodbye { + fn clear(&mut self) { + self.clear_reason(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Goodbye { + fn eq(&self, other: &Goodbye) -> bool { + self.reason == other.reason && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Goodbye { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct State { + // message fields + context_uri: ::protobuf::SingularField<::std::string::String>, + index: ::std::option::Option, + position_ms: ::std::option::Option, + status: ::std::option::Option, + position_measured_at: ::std::option::Option, + context_description: ::protobuf::SingularField<::std::string::String>, + shuffle: ::std::option::Option, + repeat: ::std::option::Option, + last_command_ident: ::protobuf::SingularField<::std::string::String>, + last_command_msgid: ::std::option::Option, + playing_from_fallback: ::std::option::Option, + row: ::std::option::Option, + playing_track_index: ::std::option::Option, + track: ::protobuf::RepeatedField, + ad: ::protobuf::SingularPtrField, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for State {} + +impl State { + pub fn new() -> State { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static State { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const State, + }; + unsafe { + instance.get(|| { + State { + context_uri: ::protobuf::SingularField::none(), + index: ::std::option::Option::None, + position_ms: ::std::option::Option::None, + status: ::std::option::Option::None, + position_measured_at: ::std::option::Option::None, + context_description: ::protobuf::SingularField::none(), + shuffle: ::std::option::Option::None, + repeat: ::std::option::Option::None, + last_command_ident: ::protobuf::SingularField::none(), + last_command_msgid: ::std::option::Option::None, + playing_from_fallback: ::std::option::Option::None, + row: ::std::option::Option::None, + playing_track_index: ::std::option::Option::None, + track: ::protobuf::RepeatedField::new(), + ad: ::protobuf::SingularPtrField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional string context_uri = 2; + + pub fn clear_context_uri(&mut self) { + self.context_uri.clear(); + } + + pub fn has_context_uri(&self) -> bool { + self.context_uri.is_some() + } + + // Param is passed by value, moved + pub fn set_context_uri(&mut self, v: ::std::string::String) { + self.context_uri = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_context_uri(&mut self) -> &mut ::std::string::String { + if self.context_uri.is_none() { + self.context_uri.set_default(); + }; + self.context_uri.as_mut().unwrap() + } + + // Take field + pub fn take_context_uri(&mut self) -> ::std::string::String { + self.context_uri.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_context_uri(&self) -> &str { + match self.context_uri.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional uint32 index = 3; + + pub fn clear_index(&mut self) { + self.index = ::std::option::Option::None; + } + + pub fn has_index(&self) -> bool { + self.index.is_some() + } + + // Param is passed by value, moved + pub fn set_index(&mut self, v: u32) { + self.index = ::std::option::Option::Some(v); + } + + pub fn get_index(&self) -> u32 { + self.index.unwrap_or(0) + } + + // optional uint32 position_ms = 4; + + pub fn clear_position_ms(&mut self) { + self.position_ms = ::std::option::Option::None; + } + + pub fn has_position_ms(&self) -> bool { + self.position_ms.is_some() + } + + // Param is passed by value, moved + pub fn set_position_ms(&mut self, v: u32) { + self.position_ms = ::std::option::Option::Some(v); + } + + pub fn get_position_ms(&self) -> u32 { + self.position_ms.unwrap_or(0) + } + + // optional .PlayStatus status = 5; + + pub fn clear_status(&mut self) { + self.status = ::std::option::Option::None; + } + + pub fn has_status(&self) -> bool { + self.status.is_some() + } + + // Param is passed by value, moved + pub fn set_status(&mut self, v: PlayStatus) { + self.status = ::std::option::Option::Some(v); + } + + pub fn get_status(&self) -> PlayStatus { + self.status.unwrap_or(PlayStatus::kPlayStatusStop) + } + + // optional uint64 position_measured_at = 7; + + pub fn clear_position_measured_at(&mut self) { + self.position_measured_at = ::std::option::Option::None; + } + + pub fn has_position_measured_at(&self) -> bool { + self.position_measured_at.is_some() + } + + // Param is passed by value, moved + pub fn set_position_measured_at(&mut self, v: u64) { + self.position_measured_at = ::std::option::Option::Some(v); + } + + pub fn get_position_measured_at(&self) -> u64 { + self.position_measured_at.unwrap_or(0) + } + + // optional string context_description = 8; + + pub fn clear_context_description(&mut self) { + self.context_description.clear(); + } + + pub fn has_context_description(&self) -> bool { + self.context_description.is_some() + } + + // Param is passed by value, moved + pub fn set_context_description(&mut self, v: ::std::string::String) { + self.context_description = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_context_description(&mut self) -> &mut ::std::string::String { + if self.context_description.is_none() { + self.context_description.set_default(); + }; + self.context_description.as_mut().unwrap() + } + + // Take field + pub fn take_context_description(&mut self) -> ::std::string::String { + self.context_description.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_context_description(&self) -> &str { + match self.context_description.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bool shuffle = 13; + + pub fn clear_shuffle(&mut self) { + self.shuffle = ::std::option::Option::None; + } + + pub fn has_shuffle(&self) -> bool { + self.shuffle.is_some() + } + + // Param is passed by value, moved + pub fn set_shuffle(&mut self, v: bool) { + self.shuffle = ::std::option::Option::Some(v); + } + + pub fn get_shuffle(&self) -> bool { + self.shuffle.unwrap_or(false) + } + + // optional bool repeat = 14; + + pub fn clear_repeat(&mut self) { + self.repeat = ::std::option::Option::None; + } + + pub fn has_repeat(&self) -> bool { + self.repeat.is_some() + } + + // Param is passed by value, moved + pub fn set_repeat(&mut self, v: bool) { + self.repeat = ::std::option::Option::Some(v); + } + + pub fn get_repeat(&self) -> bool { + self.repeat.unwrap_or(false) + } + + // optional string last_command_ident = 20; + + pub fn clear_last_command_ident(&mut self) { + self.last_command_ident.clear(); + } + + pub fn has_last_command_ident(&self) -> bool { + self.last_command_ident.is_some() + } + + // Param is passed by value, moved + pub fn set_last_command_ident(&mut self, v: ::std::string::String) { + self.last_command_ident = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_last_command_ident(&mut self) -> &mut ::std::string::String { + if self.last_command_ident.is_none() { + self.last_command_ident.set_default(); + }; + self.last_command_ident.as_mut().unwrap() + } + + // Take field + pub fn take_last_command_ident(&mut self) -> ::std::string::String { + self.last_command_ident.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_last_command_ident(&self) -> &str { + match self.last_command_ident.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional uint32 last_command_msgid = 21; + + pub fn clear_last_command_msgid(&mut self) { + self.last_command_msgid = ::std::option::Option::None; + } + + pub fn has_last_command_msgid(&self) -> bool { + self.last_command_msgid.is_some() + } + + // Param is passed by value, moved + pub fn set_last_command_msgid(&mut self, v: u32) { + self.last_command_msgid = ::std::option::Option::Some(v); + } + + pub fn get_last_command_msgid(&self) -> u32 { + self.last_command_msgid.unwrap_or(0) + } + + // optional bool playing_from_fallback = 24; + + pub fn clear_playing_from_fallback(&mut self) { + self.playing_from_fallback = ::std::option::Option::None; + } + + pub fn has_playing_from_fallback(&self) -> bool { + self.playing_from_fallback.is_some() + } + + // Param is passed by value, moved + pub fn set_playing_from_fallback(&mut self, v: bool) { + self.playing_from_fallback = ::std::option::Option::Some(v); + } + + pub fn get_playing_from_fallback(&self) -> bool { + self.playing_from_fallback.unwrap_or(false) + } + + // optional uint32 row = 25; + + pub fn clear_row(&mut self) { + self.row = ::std::option::Option::None; + } + + pub fn has_row(&self) -> bool { + self.row.is_some() + } + + // Param is passed by value, moved + pub fn set_row(&mut self, v: u32) { + self.row = ::std::option::Option::Some(v); + } + + pub fn get_row(&self) -> u32 { + self.row.unwrap_or(0) + } + + // optional uint32 playing_track_index = 26; + + pub fn clear_playing_track_index(&mut self) { + self.playing_track_index = ::std::option::Option::None; + } + + pub fn has_playing_track_index(&self) -> bool { + self.playing_track_index.is_some() + } + + // Param is passed by value, moved + pub fn set_playing_track_index(&mut self, v: u32) { + self.playing_track_index = ::std::option::Option::Some(v); + } + + pub fn get_playing_track_index(&self) -> u32 { + self.playing_track_index.unwrap_or(0) + } + + // repeated .TrackRef track = 27; + + pub fn clear_track(&mut self) { + self.track.clear(); + } + + // Param is passed by value, moved + pub fn set_track(&mut self, v: ::protobuf::RepeatedField) { + self.track = v; + } + + // Mutable pointer to the field. + pub fn mut_track(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.track + } + + // Take field + pub fn take_track(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.track, ::protobuf::RepeatedField::new()) + } + + pub fn get_track(&self) -> &[TrackRef] { + &self.track + } + + // optional .Ad ad = 28; + + pub fn clear_ad(&mut self) { + self.ad.clear(); + } + + pub fn has_ad(&self) -> bool { + self.ad.is_some() + } + + // Param is passed by value, moved + pub fn set_ad(&mut self, v: Ad) { + self.ad = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ad(&mut self) -> &mut Ad { + if self.ad.is_none() { + self.ad.set_default(); + }; + self.ad.as_mut().unwrap() + } + + // Take field + pub fn take_ad(&mut self) -> Ad { + self.ad.take().unwrap_or_else(|| Ad::new()) + } + + pub fn get_ad(&self) -> &Ad { + self.ad.as_ref().unwrap_or_else(|| Ad::default_instance()) + } +} + +impl ::protobuf::Message for State { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.context_uri)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.index = ::std::option::Option::Some(tmp); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.position_ms = ::std::option::Option::Some(tmp); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_enum()); + self.status = ::std::option::Option::Some(tmp); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint64()); + self.position_measured_at = ::std::option::Option::Some(tmp); + }, + 8 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.context_description)); + }, + 13 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.shuffle = ::std::option::Option::Some(tmp); + }, + 14 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.repeat = ::std::option::Option::Some(tmp); + }, + 20 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.last_command_ident)); + }, + 21 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.last_command_msgid = ::std::option::Option::Some(tmp); + }, + 24 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.playing_from_fallback = ::std::option::Option::Some(tmp); + }, + 25 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.row = ::std::option::Option::Some(tmp); + }, + 26 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_uint32()); + self.playing_track_index = ::std::option::Option::Some(tmp); + }, + 27 => { + try!(::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.track)); + }, + 28 => { + try!(::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ad)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.context_uri { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.index { + my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.position_ms { + my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.status { + my_size += ::protobuf::rt::enum_size(5, *value); + }; + for value in &self.position_measured_at { + my_size += ::protobuf::rt::value_size(7, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.context_description { + my_size += ::protobuf::rt::string_size(8, &value); + }; + if self.shuffle.is_some() { + my_size += 2; + }; + if self.repeat.is_some() { + my_size += 2; + }; + for value in &self.last_command_ident { + my_size += ::protobuf::rt::string_size(20, &value); + }; + for value in &self.last_command_msgid { + my_size += ::protobuf::rt::value_size(21, *value, ::protobuf::wire_format::WireTypeVarint); + }; + if self.playing_from_fallback.is_some() { + my_size += 3; + }; + for value in &self.row { + my_size += ::protobuf::rt::value_size(25, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.playing_track_index { + my_size += ::protobuf::rt::value_size(26, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.track { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.ad { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.context_uri.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.index { + try!(os.write_uint32(3, v)); + }; + if let Some(v) = self.position_ms { + try!(os.write_uint32(4, v)); + }; + if let Some(v) = self.status { + try!(os.write_enum(5, v.value())); + }; + if let Some(v) = self.position_measured_at { + try!(os.write_uint64(7, v)); + }; + if let Some(v) = self.context_description.as_ref() { + try!(os.write_string(8, &v)); + }; + if let Some(v) = self.shuffle { + try!(os.write_bool(13, v)); + }; + if let Some(v) = self.repeat { + try!(os.write_bool(14, v)); + }; + if let Some(v) = self.last_command_ident.as_ref() { + try!(os.write_string(20, &v)); + }; + if let Some(v) = self.last_command_msgid { + try!(os.write_uint32(21, v)); + }; + if let Some(v) = self.playing_from_fallback { + try!(os.write_bool(24, v)); + }; + if let Some(v) = self.row { + try!(os.write_uint32(25, v)); + }; + if let Some(v) = self.playing_track_index { + try!(os.write_uint32(26, v)); + }; + for v in &self.track { + try!(os.write_tag(27, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + if let Some(v) = self.ad.as_ref() { + try!(os.write_tag(28, ::protobuf::wire_format::WireTypeLengthDelimited)); + try!(os.write_raw_varint32(v.get_cached_size())); + try!(v.write_to_with_cached_sizes(os)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for State { + fn new() -> State { + State::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "context_uri", + State::has_context_uri, + State::get_context_uri, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "index", + State::has_index, + State::get_index, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "position_ms", + State::has_position_ms, + State::get_position_ms, + )); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor( + "status", + State::has_status, + State::get_status, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u64_accessor( + "position_measured_at", + State::has_position_measured_at, + State::get_position_measured_at, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "context_description", + State::has_context_description, + State::get_context_description, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "shuffle", + State::has_shuffle, + State::get_shuffle, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "repeat", + State::has_repeat, + State::get_repeat, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "last_command_ident", + State::has_last_command_ident, + State::get_last_command_ident, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "last_command_msgid", + State::has_last_command_msgid, + State::get_last_command_msgid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "playing_from_fallback", + State::has_playing_from_fallback, + State::get_playing_from_fallback, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "row", + State::has_row, + State::get_row, + )); + fields.push(::protobuf::reflect::accessor::make_singular_u32_accessor( + "playing_track_index", + State::has_playing_track_index, + State::get_playing_track_index, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_message_accessor( + "track", + State::get_track, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor( + "ad", + State::has_ad, + State::get_ad, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "State", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for State { + fn clear(&mut self) { + self.clear_context_uri(); + self.clear_index(); + self.clear_position_ms(); + self.clear_status(); + self.clear_position_measured_at(); + self.clear_context_description(); + self.clear_shuffle(); + self.clear_repeat(); + self.clear_last_command_ident(); + self.clear_last_command_msgid(); + self.clear_playing_from_fallback(); + self.clear_row(); + self.clear_playing_track_index(); + self.clear_track(); + self.clear_ad(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for State { + fn eq(&self, other: &State) -> bool { + self.context_uri == other.context_uri && + self.index == other.index && + self.position_ms == other.position_ms && + self.status == other.status && + self.position_measured_at == other.position_measured_at && + self.context_description == other.context_description && + self.shuffle == other.shuffle && + self.repeat == other.repeat && + self.last_command_ident == other.last_command_ident && + self.last_command_msgid == other.last_command_msgid && + self.playing_from_fallback == other.playing_from_fallback && + self.row == other.row && + self.playing_track_index == other.playing_track_index && + self.track == other.track && + self.ad == other.ad && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for State { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct TrackRef { + // message fields + gid: ::protobuf::SingularField<::std::vec::Vec>, + uri: ::protobuf::SingularField<::std::string::String>, + queued: ::std::option::Option, + context: ::protobuf::SingularField<::std::string::String>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for TrackRef {} + +impl TrackRef { + pub fn new() -> TrackRef { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static TrackRef { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TrackRef, + }; + unsafe { + instance.get(|| { + TrackRef { + gid: ::protobuf::SingularField::none(), + uri: ::protobuf::SingularField::none(), + queued: ::std::option::Option::None, + context: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional bytes gid = 1; + + pub fn clear_gid(&mut self) { + self.gid.clear(); + } + + pub fn has_gid(&self) -> bool { + self.gid.is_some() + } + + // Param is passed by value, moved + pub fn set_gid(&mut self, v: ::std::vec::Vec) { + self.gid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec { + if self.gid.is_none() { + self.gid.set_default(); + }; + self.gid.as_mut().unwrap() + } + + // Take field + pub fn take_gid(&mut self) -> ::std::vec::Vec { + self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gid(&self) -> &[u8] { + match self.gid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional string uri = 2; + + pub fn clear_uri(&mut self) { + self.uri.clear(); + } + + pub fn has_uri(&self) -> bool { + self.uri.is_some() + } + + // Param is passed by value, moved + pub fn set_uri(&mut self, v: ::std::string::String) { + self.uri = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_uri(&mut self) -> &mut ::std::string::String { + if self.uri.is_none() { + self.uri.set_default(); + }; + self.uri.as_mut().unwrap() + } + + // Take field + pub fn take_uri(&mut self) -> ::std::string::String { + self.uri.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_uri(&self) -> &str { + match self.uri.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bool queued = 3; + + pub fn clear_queued(&mut self) { + self.queued = ::std::option::Option::None; + } + + pub fn has_queued(&self) -> bool { + self.queued.is_some() + } + + // Param is passed by value, moved + pub fn set_queued(&mut self, v: bool) { + self.queued = ::std::option::Option::Some(v); + } + + pub fn get_queued(&self) -> bool { + self.queued.unwrap_or(false) + } + + // optional string context = 4; + + pub fn clear_context(&mut self) { + self.context.clear(); + } + + pub fn has_context(&self) -> bool { + self.context.is_some() + } + + // Param is passed by value, moved + pub fn set_context(&mut self, v: ::std::string::String) { + self.context = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_context(&mut self) -> &mut ::std::string::String { + if self.context.is_none() { + self.context.set_default(); + }; + self.context.as_mut().unwrap() + } + + // Take field + pub fn take_context(&mut self) -> ::std::string::String { + self.context.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_context(&self) -> &str { + match self.context.as_ref() { + Some(v) => &v, + None => "", + } + } +} + +impl ::protobuf::Message for TrackRef { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)); + }, + 2 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_bool()); + self.queued = ::std::option::Option::Some(tmp); + }, + 4 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.context)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.gid { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.uri { + my_size += ::protobuf::rt::string_size(2, &value); + }; + if self.queued.is_some() { + my_size += 2; + }; + for value in &self.context { + my_size += ::protobuf::rt::string_size(4, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.gid.as_ref() { + try!(os.write_bytes(1, &v)); + }; + if let Some(v) = self.uri.as_ref() { + try!(os.write_string(2, &v)); + }; + if let Some(v) = self.queued { + try!(os.write_bool(3, v)); + }; + if let Some(v) = self.context.as_ref() { + try!(os.write_string(4, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for TrackRef { + fn new() -> TrackRef { + TrackRef::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gid", + TrackRef::has_gid, + TrackRef::get_gid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "uri", + TrackRef::has_uri, + TrackRef::get_uri, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor( + "queued", + TrackRef::has_queued, + TrackRef::get_queued, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "context", + TrackRef::has_context, + TrackRef::get_context, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TrackRef", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for TrackRef { + fn clear(&mut self) { + self.clear_gid(); + self.clear_uri(); + self.clear_queued(); + self.clear_context(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for TrackRef { + fn eq(&self, other: &TrackRef) -> bool { + self.gid == other.gid && + self.uri == other.uri && + self.queued == other.queued && + self.context == other.context && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for TrackRef { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,Default)] +pub struct Ad { + // message fields + next: ::std::option::Option, + ogg_fid: ::protobuf::SingularField<::std::vec::Vec>, + image_fid: ::protobuf::SingularField<::std::vec::Vec>, + duration: ::std::option::Option, + click_url: ::protobuf::SingularField<::std::string::String>, + impression_url: ::protobuf::SingularField<::std::string::String>, + product: ::protobuf::SingularField<::std::string::String>, + advertiser: ::protobuf::SingularField<::std::string::String>, + gid: ::protobuf::SingularField<::std::vec::Vec>, + // special fields + unknown_fields: ::protobuf::UnknownFields, + cached_size: ::std::cell::Cell, +} + +// see codegen.rs for the explanation why impl Sync explicitly +unsafe impl ::std::marker::Sync for Ad {} + +impl Ad { + pub fn new() -> Ad { + ::std::default::Default::default() + } + + pub fn default_instance() -> &'static Ad { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Ad, + }; + unsafe { + instance.get(|| { + Ad { + next: ::std::option::Option::None, + ogg_fid: ::protobuf::SingularField::none(), + image_fid: ::protobuf::SingularField::none(), + duration: ::std::option::Option::None, + click_url: ::protobuf::SingularField::none(), + impression_url: ::protobuf::SingularField::none(), + product: ::protobuf::SingularField::none(), + advertiser: ::protobuf::SingularField::none(), + gid: ::protobuf::SingularField::none(), + unknown_fields: ::protobuf::UnknownFields::new(), + cached_size: ::std::cell::Cell::new(0), + } + }) + } + } + + // optional int32 next = 1; + + pub fn clear_next(&mut self) { + self.next = ::std::option::Option::None; + } + + pub fn has_next(&self) -> bool { + self.next.is_some() + } + + // Param is passed by value, moved + pub fn set_next(&mut self, v: i32) { + self.next = ::std::option::Option::Some(v); + } + + pub fn get_next(&self) -> i32 { + self.next.unwrap_or(0) + } + + // optional bytes ogg_fid = 2; + + pub fn clear_ogg_fid(&mut self) { + self.ogg_fid.clear(); + } + + pub fn has_ogg_fid(&self) -> bool { + self.ogg_fid.is_some() + } + + // Param is passed by value, moved + pub fn set_ogg_fid(&mut self, v: ::std::vec::Vec) { + self.ogg_fid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ogg_fid(&mut self) -> &mut ::std::vec::Vec { + if self.ogg_fid.is_none() { + self.ogg_fid.set_default(); + }; + self.ogg_fid.as_mut().unwrap() + } + + // Take field + pub fn take_ogg_fid(&mut self) -> ::std::vec::Vec { + self.ogg_fid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_ogg_fid(&self) -> &[u8] { + match self.ogg_fid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional bytes image_fid = 3; + + pub fn clear_image_fid(&mut self) { + self.image_fid.clear(); + } + + pub fn has_image_fid(&self) -> bool { + self.image_fid.is_some() + } + + // Param is passed by value, moved + pub fn set_image_fid(&mut self, v: ::std::vec::Vec) { + self.image_fid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_image_fid(&mut self) -> &mut ::std::vec::Vec { + if self.image_fid.is_none() { + self.image_fid.set_default(); + }; + self.image_fid.as_mut().unwrap() + } + + // Take field + pub fn take_image_fid(&mut self) -> ::std::vec::Vec { + self.image_fid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_image_fid(&self) -> &[u8] { + match self.image_fid.as_ref() { + Some(v) => &v, + None => &[], + } + } + + // optional int32 duration = 4; + + pub fn clear_duration(&mut self) { + self.duration = ::std::option::Option::None; + } + + pub fn has_duration(&self) -> bool { + self.duration.is_some() + } + + // Param is passed by value, moved + pub fn set_duration(&mut self, v: i32) { + self.duration = ::std::option::Option::Some(v); + } + + pub fn get_duration(&self) -> i32 { + self.duration.unwrap_or(0) + } + + // optional string click_url = 5; + + pub fn clear_click_url(&mut self) { + self.click_url.clear(); + } + + pub fn has_click_url(&self) -> bool { + self.click_url.is_some() + } + + // Param is passed by value, moved + pub fn set_click_url(&mut self, v: ::std::string::String) { + self.click_url = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_click_url(&mut self) -> &mut ::std::string::String { + if self.click_url.is_none() { + self.click_url.set_default(); + }; + self.click_url.as_mut().unwrap() + } + + // Take field + pub fn take_click_url(&mut self) -> ::std::string::String { + self.click_url.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_click_url(&self) -> &str { + match self.click_url.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string impression_url = 6; + + pub fn clear_impression_url(&mut self) { + self.impression_url.clear(); + } + + pub fn has_impression_url(&self) -> bool { + self.impression_url.is_some() + } + + // Param is passed by value, moved + pub fn set_impression_url(&mut self, v: ::std::string::String) { + self.impression_url = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_impression_url(&mut self) -> &mut ::std::string::String { + if self.impression_url.is_none() { + self.impression_url.set_default(); + }; + self.impression_url.as_mut().unwrap() + } + + // Take field + pub fn take_impression_url(&mut self) -> ::std::string::String { + self.impression_url.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_impression_url(&self) -> &str { + match self.impression_url.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string product = 7; + + pub fn clear_product(&mut self) { + self.product.clear(); + } + + pub fn has_product(&self) -> bool { + self.product.is_some() + } + + // Param is passed by value, moved + pub fn set_product(&mut self, v: ::std::string::String) { + self.product = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_product(&mut self) -> &mut ::std::string::String { + if self.product.is_none() { + self.product.set_default(); + }; + self.product.as_mut().unwrap() + } + + // Take field + pub fn take_product(&mut self) -> ::std::string::String { + self.product.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_product(&self) -> &str { + match self.product.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional string advertiser = 8; + + pub fn clear_advertiser(&mut self) { + self.advertiser.clear(); + } + + pub fn has_advertiser(&self) -> bool { + self.advertiser.is_some() + } + + // Param is passed by value, moved + pub fn set_advertiser(&mut self, v: ::std::string::String) { + self.advertiser = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_advertiser(&mut self) -> &mut ::std::string::String { + if self.advertiser.is_none() { + self.advertiser.set_default(); + }; + self.advertiser.as_mut().unwrap() + } + + // Take field + pub fn take_advertiser(&mut self) -> ::std::string::String { + self.advertiser.take().unwrap_or_else(|| ::std::string::String::new()) + } + + pub fn get_advertiser(&self) -> &str { + match self.advertiser.as_ref() { + Some(v) => &v, + None => "", + } + } + + // optional bytes gid = 9; + + pub fn clear_gid(&mut self) { + self.gid.clear(); + } + + pub fn has_gid(&self) -> bool { + self.gid.is_some() + } + + // Param is passed by value, moved + pub fn set_gid(&mut self, v: ::std::vec::Vec) { + self.gid = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec { + if self.gid.is_none() { + self.gid.set_default(); + }; + self.gid.as_mut().unwrap() + } + + // Take field + pub fn take_gid(&mut self) -> ::std::vec::Vec { + self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + pub fn get_gid(&self) -> &[u8] { + match self.gid.as_ref() { + Some(v) => &v, + None => &[], + } + } +} + +impl ::protobuf::Message for Ad { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !try!(is.eof()) { + let (field_number, wire_type) = try!(is.read_tag_unpack()); + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.next = ::std::option::Option::Some(tmp); + }, + 2 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ogg_fid)); + }, + 3 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.image_fid)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + }; + let tmp = try!(is.read_int32()); + self.duration = ::std::option::Option::Some(tmp); + }, + 5 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.click_url)); + }, + 6 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.impression_url)); + }, + 7 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.product)); + }, + 8 => { + try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.advertiser)); + }, + 9 => { + try!(::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)); + }, + _ => { + try!(::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())); + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.next { + my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.ogg_fid { + my_size += ::protobuf::rt::bytes_size(2, &value); + }; + for value in &self.image_fid { + my_size += ::protobuf::rt::bytes_size(3, &value); + }; + for value in &self.duration { + my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.click_url { + my_size += ::protobuf::rt::string_size(5, &value); + }; + for value in &self.impression_url { + my_size += ::protobuf::rt::string_size(6, &value); + }; + for value in &self.product { + my_size += ::protobuf::rt::string_size(7, &value); + }; + for value in &self.advertiser { + my_size += ::protobuf::rt::string_size(8, &value); + }; + for value in &self.gid { + my_size += ::protobuf::rt::bytes_size(9, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.next { + try!(os.write_int32(1, v)); + }; + if let Some(v) = self.ogg_fid.as_ref() { + try!(os.write_bytes(2, &v)); + }; + if let Some(v) = self.image_fid.as_ref() { + try!(os.write_bytes(3, &v)); + }; + if let Some(v) = self.duration { + try!(os.write_int32(4, v)); + }; + if let Some(v) = self.click_url.as_ref() { + try!(os.write_string(5, &v)); + }; + if let Some(v) = self.impression_url.as_ref() { + try!(os.write_string(6, &v)); + }; + if let Some(v) = self.product.as_ref() { + try!(os.write_string(7, &v)); + }; + if let Some(v) = self.advertiser.as_ref() { + try!(os.write_string(8, &v)); + }; + if let Some(v) = self.gid.as_ref() { + try!(os.write_bytes(9, &v)); + }; + try!(os.write_unknown_fields(self.get_unknown_fields())); + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn type_id(&self) -> ::std::any::TypeId { + ::std::any::TypeId::of::() + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + ::protobuf::MessageStatic::descriptor_static(None::) + } +} + +impl ::protobuf::MessageStatic for Ad { + fn new() -> Ad { + Ad::new() + } + + fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "next", + Ad::has_next, + Ad::get_next, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "ogg_fid", + Ad::has_ogg_fid, + Ad::get_ogg_fid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "image_fid", + Ad::has_image_fid, + Ad::get_image_fid, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( + "duration", + Ad::has_duration, + Ad::get_duration, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "click_url", + Ad::has_click_url, + Ad::get_click_url, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "impression_url", + Ad::has_impression_url, + Ad::get_impression_url, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "product", + Ad::has_product, + Ad::get_product, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor( + "advertiser", + Ad::has_advertiser, + Ad::get_advertiser, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor( + "gid", + Ad::has_gid, + Ad::get_gid, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Ad", + fields, + file_descriptor_proto() + ) + }) + } + } +} + +impl ::protobuf::Clear for Ad { + fn clear(&mut self) { + self.clear_next(); + self.clear_ogg_fid(); + self.clear_image_fid(); + self.clear_duration(); + self.clear_click_url(); + self.clear_impression_url(); + self.clear_product(); + self.clear_advertiser(); + self.clear_gid(); + self.unknown_fields.clear(); + } +} + +impl ::std::cmp::PartialEq for Ad { + fn eq(&self, other: &Ad) -> bool { + self.next == other.next && + self.ogg_fid == other.ogg_fid && + self.image_fid == other.image_fid && + self.duration == other.duration && + self.click_url == other.click_url && + self.impression_url == other.impression_url && + self.product == other.product && + self.advertiser == other.advertiser && + self.gid == other.gid && + self.unknown_fields == other.unknown_fields + } +} + +impl ::std::fmt::Debug for Ad { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum MessageType { + kMessageTypeHello = 1, + kMessageTypeGoodbye = 2, + kMessageTypeProbe = 3, + kMessageTypeNotify = 10, + kMessageTypeLoad = 20, + kMessageTypePlay = 21, + kMessageTypePause = 22, + kMessageTypePlayPause = 23, + kMessageTypeSeek = 24, + kMessageTypePrev = 25, + kMessageTypeNext = 26, + kMessageTypeVolume = 27, + kMessageTypeShuffle = 28, + kMessageTypeRepeat = 29, + kMessageTypeVolumeDown = 31, + kMessageTypeVolumeUp = 32, + kMessageTypeReplace = 33, + kMessageTypeLogout = 34, + kMessageTypeAction = 35, + kMessageTypeRename = 36, +} + +impl ::protobuf::ProtobufEnum for MessageType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(MessageType::kMessageTypeHello), + 2 => ::std::option::Option::Some(MessageType::kMessageTypeGoodbye), + 3 => ::std::option::Option::Some(MessageType::kMessageTypeProbe), + 10 => ::std::option::Option::Some(MessageType::kMessageTypeNotify), + 20 => ::std::option::Option::Some(MessageType::kMessageTypeLoad), + 21 => ::std::option::Option::Some(MessageType::kMessageTypePlay), + 22 => ::std::option::Option::Some(MessageType::kMessageTypePause), + 23 => ::std::option::Option::Some(MessageType::kMessageTypePlayPause), + 24 => ::std::option::Option::Some(MessageType::kMessageTypeSeek), + 25 => ::std::option::Option::Some(MessageType::kMessageTypePrev), + 26 => ::std::option::Option::Some(MessageType::kMessageTypeNext), + 27 => ::std::option::Option::Some(MessageType::kMessageTypeVolume), + 28 => ::std::option::Option::Some(MessageType::kMessageTypeShuffle), + 29 => ::std::option::Option::Some(MessageType::kMessageTypeRepeat), + 31 => ::std::option::Option::Some(MessageType::kMessageTypeVolumeDown), + 32 => ::std::option::Option::Some(MessageType::kMessageTypeVolumeUp), + 33 => ::std::option::Option::Some(MessageType::kMessageTypeReplace), + 34 => ::std::option::Option::Some(MessageType::kMessageTypeLogout), + 35 => ::std::option::Option::Some(MessageType::kMessageTypeAction), + 36 => ::std::option::Option::Some(MessageType::kMessageTypeRename), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [MessageType] = &[ + MessageType::kMessageTypeHello, + MessageType::kMessageTypeGoodbye, + MessageType::kMessageTypeProbe, + MessageType::kMessageTypeNotify, + MessageType::kMessageTypeLoad, + MessageType::kMessageTypePlay, + MessageType::kMessageTypePause, + MessageType::kMessageTypePlayPause, + MessageType::kMessageTypeSeek, + MessageType::kMessageTypePrev, + MessageType::kMessageTypeNext, + MessageType::kMessageTypeVolume, + MessageType::kMessageTypeShuffle, + MessageType::kMessageTypeRepeat, + MessageType::kMessageTypeVolumeDown, + MessageType::kMessageTypeVolumeUp, + MessageType::kMessageTypeReplace, + MessageType::kMessageTypeLogout, + MessageType::kMessageTypeAction, + MessageType::kMessageTypeRename, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("MessageType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for MessageType { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum CapabilityType { + kSupportedContexts = 1, + kCanBePlayer = 2, + kRestrictToLocal = 3, + kDeviceType = 4, + kGaiaEqConnectId = 5, + kSupportsLogout = 6, + kIsObservable = 7, + kVolumeSteps = 8, + kSupportedTypes = 9, + kCommandAcks = 10, + kSupportsRename = 11, +} + +impl ::protobuf::ProtobufEnum for CapabilityType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(CapabilityType::kSupportedContexts), + 2 => ::std::option::Option::Some(CapabilityType::kCanBePlayer), + 3 => ::std::option::Option::Some(CapabilityType::kRestrictToLocal), + 4 => ::std::option::Option::Some(CapabilityType::kDeviceType), + 5 => ::std::option::Option::Some(CapabilityType::kGaiaEqConnectId), + 6 => ::std::option::Option::Some(CapabilityType::kSupportsLogout), + 7 => ::std::option::Option::Some(CapabilityType::kIsObservable), + 8 => ::std::option::Option::Some(CapabilityType::kVolumeSteps), + 9 => ::std::option::Option::Some(CapabilityType::kSupportedTypes), + 10 => ::std::option::Option::Some(CapabilityType::kCommandAcks), + 11 => ::std::option::Option::Some(CapabilityType::kSupportsRename), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [CapabilityType] = &[ + CapabilityType::kSupportedContexts, + CapabilityType::kCanBePlayer, + CapabilityType::kRestrictToLocal, + CapabilityType::kDeviceType, + CapabilityType::kGaiaEqConnectId, + CapabilityType::kSupportsLogout, + CapabilityType::kIsObservable, + CapabilityType::kVolumeSteps, + CapabilityType::kSupportedTypes, + CapabilityType::kCommandAcks, + CapabilityType::kSupportsRename, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("CapabilityType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for CapabilityType { +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum PlayStatus { + kPlayStatusStop = 0, + kPlayStatusPlay = 1, + kPlayStatusPause = 2, + kPlayStatusLoading = 3, +} + +impl ::protobuf::ProtobufEnum for PlayStatus { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(PlayStatus::kPlayStatusStop), + 1 => ::std::option::Option::Some(PlayStatus::kPlayStatusPlay), + 2 => ::std::option::Option::Some(PlayStatus::kPlayStatusPause), + 3 => ::std::option::Option::Some(PlayStatus::kPlayStatusLoading), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [PlayStatus] = &[ + PlayStatus::kPlayStatusStop, + PlayStatus::kPlayStatusPlay, + PlayStatus::kPlayStatusPause, + PlayStatus::kPlayStatusLoading, + ]; + values + } + + fn enum_descriptor_static(_: Option) -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("PlayStatus", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for PlayStatus { +} + +static file_descriptor_proto_data: &'static [u8] = &[ + 0x0a, 0x0b, 0x73, 0x70, 0x69, 0x72, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd3, 0x03, + 0x0a, 0x05, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x73, 0x65, 0x71, 0x5f, 0x6e, 0x72, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x05, 0x73, 0x65, 0x71, 0x4e, 0x72, 0x12, 0x1e, 0x0a, 0x03, 0x74, 0x79, 0x70, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x03, 0x74, 0x79, 0x70, 0x12, 0x2f, 0x0a, 0x0c, 0x64, 0x65, 0x76, + 0x69, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0b, 0x64, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x07, 0x67, 0x6f, + 0x6f, 0x64, 0x62, 0x79, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x08, 0x2e, 0x47, 0x6f, + 0x6f, 0x64, 0x62, 0x79, 0x65, 0x52, 0x07, 0x67, 0x6f, 0x6f, 0x64, 0x62, 0x79, 0x65, 0x12, 0x1c, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x06, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x5f, 0x69, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x69, + 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x63, + 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x13, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x50, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4e, + 0x61, 0x6d, 0x65, 0x22, 0xaf, 0x02, 0x0a, 0x0b, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x77, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x77, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, + 0x19, 0x0a, 0x08, 0x63, 0x61, 0x6e, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x07, 0x63, 0x61, 0x6e, 0x50, 0x6c, 0x61, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, + 0x63, 0x6f, 0x64, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x5f, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0e, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x41, 0x74, 0x12, + 0x23, 0x0a, 0x0d, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x2f, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x43, 0x61, 0x70, + 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x6d, 0x0a, 0x0a, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x12, 0x21, 0x0a, 0x03, 0x74, 0x79, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x0f, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x03, 0x74, 0x79, 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x07, 0x47, 0x6f, 0x6f, 0x64, 0x62, 0x79, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0xa1, 0x04, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x75, 0x72, 0x69, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x55, + 0x72, 0x69, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x12, 0x23, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0b, 0x2e, 0x50, 0x6c, 0x61, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x30, + 0x0a, 0x14, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x65, 0x61, 0x73, 0x75, + 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x64, 0x41, 0x74, + 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x18, 0x0d, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x07, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x72, 0x65, 0x70, + 0x65, 0x61, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x6c, 0x61, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x5f, 0x6d, 0x73, 0x67, 0x69, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x6c, + 0x61, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4d, 0x73, 0x67, 0x69, 0x64, 0x12, + 0x32, 0x0a, 0x15, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, + 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, + 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6c, 0x6c, 0x62, + 0x61, 0x63, 0x6b, 0x12, 0x10, 0x0a, 0x03, 0x72, 0x6f, 0x77, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x03, 0x72, 0x6f, 0x77, 0x12, 0x2e, 0x0a, 0x13, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, + 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x1a, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x11, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x63, 0x6b, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x18, 0x1b, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, 0x65, 0x66, 0x52, + 0x05, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x12, 0x13, 0x0a, 0x02, 0x61, 0x64, 0x18, 0x1c, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x03, 0x2e, 0x41, 0x64, 0x52, 0x02, 0x61, 0x64, 0x22, 0x60, 0x0a, 0x08, 0x54, + 0x72, 0x61, 0x63, 0x6b, 0x52, 0x65, 0x66, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x67, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x16, 0x0a, 0x06, 0x71, + 0x75, 0x65, 0x75, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x71, 0x75, 0x65, + 0x75, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0xfa, 0x01, + 0x0a, 0x02, 0x41, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x04, 0x6e, 0x65, 0x78, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6f, 0x67, 0x67, 0x5f, + 0x66, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x6f, 0x67, 0x67, 0x46, 0x69, + 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x46, 0x69, 0x64, 0x12, 0x1a, + 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6c, + 0x69, 0x63, 0x6b, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, + 0x6c, 0x69, 0x63, 0x6b, 0x55, 0x72, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6d, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x69, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x72, 0x6c, 0x12, 0x18, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x64, 0x76, 0x65, + 0x72, 0x74, 0x69, 0x73, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, + 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x69, 0x64, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x67, 0x69, 0x64, 0x2a, 0xec, 0x03, 0x0a, 0x0b, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x6b, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x10, + 0x01, 0x12, 0x17, 0x0a, 0x13, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x47, 0x6f, 0x6f, 0x64, 0x62, 0x79, 0x65, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x6b, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x10, + 0x03, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x10, 0x0a, 0x12, 0x14, 0x0a, 0x10, 0x6b, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x10, 0x14, 0x12, + 0x14, 0x0a, 0x10, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x50, + 0x6c, 0x61, 0x79, 0x10, 0x15, 0x12, 0x15, 0x0a, 0x11, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x10, 0x16, 0x12, 0x19, 0x0a, 0x15, + 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x50, 0x6c, 0x61, 0x79, + 0x50, 0x61, 0x75, 0x73, 0x65, 0x10, 0x17, 0x12, 0x14, 0x0a, 0x10, 0x6b, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x53, 0x65, 0x65, 0x6b, 0x10, 0x18, 0x12, 0x14, 0x0a, + 0x10, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x50, 0x72, 0x65, + 0x76, 0x10, 0x19, 0x12, 0x14, 0x0a, 0x10, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x4e, 0x65, 0x78, 0x74, 0x10, 0x1a, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x10, + 0x1b, 0x12, 0x17, 0x0a, 0x13, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x53, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x10, 0x1c, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, + 0x10, 0x1d, 0x12, 0x1a, 0x0a, 0x16, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x44, 0x6f, 0x77, 0x6e, 0x10, 0x1f, 0x12, 0x18, + 0x0a, 0x14, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x55, 0x70, 0x10, 0x20, 0x12, 0x17, 0x0a, 0x13, 0x6b, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x10, + 0x21, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x4c, 0x6f, 0x67, 0x6f, 0x75, 0x74, 0x10, 0x22, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, + 0x23, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x10, 0x24, 0x2a, 0xed, 0x01, 0x0a, 0x0e, 0x43, 0x61, + 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x12, + 0x6b, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x73, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x6b, 0x43, 0x61, 0x6e, 0x42, 0x65, 0x50, 0x6c, + 0x61, 0x79, 0x65, 0x72, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, + 0x69, 0x63, 0x74, 0x54, 0x6f, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, + 0x6b, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x10, 0x04, 0x12, 0x14, 0x0a, + 0x10, 0x6b, 0x47, 0x61, 0x69, 0x61, 0x45, 0x71, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x49, + 0x64, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x6b, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, + 0x4c, 0x6f, 0x67, 0x6f, 0x75, 0x74, 0x10, 0x06, 0x12, 0x11, 0x0a, 0x0d, 0x6b, 0x49, 0x73, 0x4f, + 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x10, 0x07, 0x12, 0x10, 0x0a, 0x0c, 0x6b, + 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x65, 0x70, 0x73, 0x10, 0x08, 0x12, 0x13, 0x0a, + 0x0f, 0x6b, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x10, 0x09, 0x12, 0x10, 0x0a, 0x0c, 0x6b, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x41, 0x63, + 0x6b, 0x73, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x6b, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x73, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x10, 0x0b, 0x2a, 0x64, 0x0a, 0x0a, 0x50, 0x6c, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x13, 0x0a, 0x0f, 0x6b, 0x50, 0x6c, 0x61, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x74, 0x6f, 0x70, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, + 0x6b, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x50, 0x6c, 0x61, 0x79, 0x10, + 0x01, 0x12, 0x14, 0x0a, 0x10, 0x6b, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x50, 0x61, 0x75, 0x73, 0x65, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x6b, 0x50, 0x6c, 0x61, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x10, 0x03, 0x4a, + 0xf0, 0x2a, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x78, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, + 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, 0x00, 0x11, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x03, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x03, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x03, 0x1e, + 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x04, 0x04, 0x20, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x04, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x04, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x04, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x04, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x05, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x05, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x05, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x05, 0x14, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x05, 0x27, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x06, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, + 0x04, 0x12, 0x03, 0x06, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, + 0x03, 0x06, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x06, + 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x06, 0x1d, 0x20, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x07, 0x04, 0x23, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x04, 0x04, 0x12, 0x03, 0x07, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x07, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x07, 0x19, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x07, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x08, + 0x04, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x04, 0x12, 0x03, 0x08, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x08, 0x0d, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x08, 0x19, 0x25, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x08, 0x28, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x06, 0x12, 0x03, 0x09, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x04, + 0x12, 0x03, 0x09, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, + 0x09, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x09, 0x15, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x09, 0x1f, 0x22, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x0a, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x04, 0x12, 0x03, 0x0a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x07, 0x06, 0x12, 0x03, 0x0a, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, + 0x01, 0x12, 0x03, 0x0a, 0x13, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x03, 0x12, + 0x03, 0x0a, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x0b, 0x04, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x04, 0x12, 0x03, 0x0b, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x05, 0x12, 0x03, 0x0b, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x0b, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x0b, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x09, 0x12, 0x03, 0x0c, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x04, 0x12, + 0x03, 0x0c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x05, 0x12, 0x03, 0x0c, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x0c, 0x14, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x03, 0x12, 0x03, 0x0c, 0x1d, 0x20, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x0d, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x0a, 0x04, 0x12, 0x03, 0x0d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x0a, 0x05, 0x12, 0x03, 0x0d, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x01, + 0x12, 0x03, 0x0d, 0x13, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x03, 0x12, 0x03, + 0x0d, 0x25, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0b, 0x12, 0x03, 0x0e, 0x04, 0x25, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x04, 0x12, 0x03, 0x0e, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x05, 0x12, 0x03, 0x0e, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x0e, 0x14, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x0b, 0x03, 0x12, 0x03, 0x0e, 0x20, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0c, + 0x12, 0x03, 0x0f, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x04, 0x12, 0x03, + 0x0f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x05, 0x12, 0x03, 0x0f, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x0f, 0x13, 0x27, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x0f, 0x2a, 0x2e, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x0d, 0x12, 0x03, 0x10, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x0d, 0x04, 0x12, 0x03, 0x10, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, + 0x05, 0x12, 0x03, 0x10, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x01, 0x12, + 0x03, 0x10, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x10, + 0x1f, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x13, 0x00, 0x28, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x13, 0x05, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x14, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x14, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x14, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x15, 0x04, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x15, 0x04, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x15, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x16, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x16, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x16, 0x18, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x17, + 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x17, 0x04, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x17, 0x19, 0x1c, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x18, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x18, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x04, 0x02, 0x12, 0x03, 0x18, 0x17, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, + 0x03, 0x19, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x19, + 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x19, 0x17, 0x1b, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, 0x03, 0x1a, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x1a, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x1a, 0x18, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x07, 0x12, 0x03, 0x1b, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x01, 0x12, + 0x03, 0x1b, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x1b, + 0x1c, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x08, 0x12, 0x03, 0x1c, 0x04, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x1c, 0x04, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x1c, 0x17, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x09, 0x12, 0x03, 0x1d, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x09, + 0x01, 0x12, 0x03, 0x1d, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x09, 0x02, 0x12, + 0x03, 0x1d, 0x17, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x1e, 0x04, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x1e, 0x04, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x03, 0x1e, 0x17, 0x1b, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x0b, 0x12, 0x03, 0x1f, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x0b, 0x01, 0x12, 0x03, 0x1f, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0b, + 0x02, 0x12, 0x03, 0x1f, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0c, 0x12, 0x03, + 0x20, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x20, 0x04, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0c, 0x02, 0x12, 0x03, 0x20, 0x1a, 0x1e, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0d, 0x12, 0x03, 0x21, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x21, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x0d, 0x02, 0x12, 0x03, 0x21, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0e, + 0x12, 0x03, 0x22, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0e, 0x01, 0x12, 0x03, + 0x22, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0e, 0x02, 0x12, 0x03, 0x22, 0x1d, + 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0f, 0x12, 0x03, 0x23, 0x04, 0x20, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x23, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x0f, 0x02, 0x12, 0x03, 0x23, 0x1b, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x10, 0x12, 0x03, 0x24, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x10, 0x01, + 0x12, 0x03, 0x24, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x10, 0x02, 0x12, 0x03, + 0x24, 0x1a, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x11, 0x12, 0x03, 0x25, 0x04, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x11, 0x01, 0x12, 0x03, 0x25, 0x04, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x11, 0x02, 0x12, 0x03, 0x25, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x12, 0x12, 0x03, 0x26, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x12, 0x01, 0x12, 0x03, 0x26, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x12, 0x02, + 0x12, 0x03, 0x26, 0x19, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x13, 0x12, 0x03, 0x27, + 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x13, 0x01, 0x12, 0x03, 0x27, 0x04, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x13, 0x02, 0x12, 0x03, 0x27, 0x19, 0x1d, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x2a, 0x00, 0x34, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x2a, 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x2b, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x2b, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2b, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x04, 0x12, 0x03, 0x2c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x2c, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, + 0x12, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x1e, 0x21, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x2d, 0x04, 0x21, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x2d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x2d, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x2d, 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x2d, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x2e, + 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x2e, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x2e, 0x0d, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x2e, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x2e, 0x1d, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x04, 0x12, 0x03, 0x2f, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x04, + 0x12, 0x03, 0x2f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, + 0x2f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2f, 0x14, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2f, 0x1b, 0x1e, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x30, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x05, 0x04, 0x12, 0x03, 0x30, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x05, 0x05, 0x12, 0x03, 0x30, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, + 0x01, 0x12, 0x03, 0x30, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, + 0x03, 0x30, 0x21, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x31, 0x04, + 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x04, 0x12, 0x03, 0x31, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, 0x31, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x31, 0x13, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x31, 0x26, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x07, 0x12, 0x03, 0x32, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x04, 0x12, + 0x03, 0x32, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x05, 0x12, 0x03, 0x32, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x32, 0x14, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x32, 0x24, 0x28, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x08, 0x12, 0x03, 0x33, 0x04, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x08, 0x04, 0x12, 0x03, 0x33, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x08, 0x06, 0x12, 0x03, 0x33, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x01, + 0x12, 0x03, 0x33, 0x18, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x03, 0x12, 0x03, + 0x33, 0x27, 0x2b, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x36, 0x00, 0x3a, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x36, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x00, 0x12, 0x03, 0x37, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x37, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x37, 0x0d, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x37, + 0x1c, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x37, 0x22, 0x25, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x38, 0x04, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x38, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x38, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x38, 0x13, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x38, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x39, + 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, 0x03, 0x39, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x39, 0x0d, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x39, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x39, 0x22, 0x25, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, + 0x12, 0x04, 0x3c, 0x00, 0x48, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x3c, + 0x05, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x3d, 0x04, 0x1d, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3d, 0x04, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x01, 0x02, 0x00, 0x02, 0x12, 0x03, 0x3d, 0x19, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x3e, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x3e, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x3e, 0x13, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x02, 0x12, 0x03, 0x3f, 0x04, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x04, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x02, 0x12, 0x03, 0x3f, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x01, 0x02, 0x03, 0x12, 0x03, 0x40, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x40, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x03, + 0x02, 0x12, 0x03, 0x40, 0x12, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x04, 0x12, 0x03, + 0x41, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x41, 0x04, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x04, 0x02, 0x12, 0x03, 0x41, 0x17, 0x1a, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x05, 0x12, 0x03, 0x42, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x42, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, + 0x02, 0x05, 0x02, 0x12, 0x03, 0x42, 0x16, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x06, + 0x12, 0x03, 0x43, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, + 0x43, 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x06, 0x02, 0x12, 0x03, 0x43, 0x14, + 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x07, 0x12, 0x03, 0x44, 0x04, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x44, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x01, 0x02, 0x07, 0x02, 0x12, 0x03, 0x44, 0x13, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, + 0x02, 0x08, 0x12, 0x03, 0x45, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x08, 0x01, + 0x12, 0x03, 0x45, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x08, 0x02, 0x12, 0x03, + 0x45, 0x16, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x09, 0x12, 0x03, 0x46, 0x04, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x09, 0x01, 0x12, 0x03, 0x46, 0x04, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x01, 0x02, 0x09, 0x02, 0x12, 0x03, 0x46, 0x13, 0x16, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x01, 0x02, 0x0a, 0x12, 0x03, 0x47, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, + 0x0a, 0x01, 0x12, 0x03, 0x47, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x0a, 0x02, + 0x12, 0x03, 0x47, 0x16, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x4a, 0x00, 0x4c, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x4a, 0x08, 0x0f, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x4b, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x4b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x4b, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x4b, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4b, + 0x1d, 0x20, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x4e, 0x00, 0x5e, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x4e, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, + 0x02, 0x00, 0x12, 0x03, 0x4f, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x4f, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x4f, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4f, 0x14, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4f, 0x22, 0x25, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x50, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x04, 0x12, 0x03, 0x50, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x50, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x50, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x50, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x51, 0x04, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x51, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x51, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x51, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x51, 0x22, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, + 0x03, 0x12, 0x03, 0x52, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, + 0x03, 0x52, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x06, 0x12, 0x03, 0x52, + 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x52, 0x18, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x52, 0x21, 0x24, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x53, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x04, 0x04, 0x12, 0x03, 0x53, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x53, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x53, 0x14, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x53, 0x2b, 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x05, 0x12, 0x03, 0x54, 0x04, 0x2e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x04, 0x12, 0x03, 0x54, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x05, 0x12, 0x03, 0x54, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x05, 0x01, 0x12, 0x03, 0x54, 0x14, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x05, 0x03, 0x12, 0x03, 0x54, 0x2a, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x06, + 0x12, 0x03, 0x55, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x04, 0x12, 0x03, + 0x55, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x05, 0x12, 0x03, 0x55, 0x0d, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, 0x12, 0x03, 0x55, 0x12, 0x19, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, 0x03, 0x55, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x07, 0x12, 0x03, 0x56, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x07, 0x04, 0x12, 0x03, 0x56, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, + 0x05, 0x12, 0x03, 0x56, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x01, 0x12, + 0x03, 0x56, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x03, 0x12, 0x03, 0x56, + 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x08, 0x12, 0x03, 0x57, 0x04, 0x2e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x08, 0x04, 0x12, 0x03, 0x57, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x08, 0x05, 0x12, 0x03, 0x57, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x08, 0x01, 0x12, 0x03, 0x57, 0x14, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x08, 0x03, 0x12, 0x03, 0x57, 0x29, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x09, 0x12, + 0x03, 0x58, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x04, 0x12, 0x03, 0x58, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x05, 0x12, 0x03, 0x58, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x01, 0x12, 0x03, 0x58, 0x14, 0x26, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x03, 0x12, 0x03, 0x58, 0x29, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x0a, 0x12, 0x03, 0x59, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x0a, 0x04, 0x12, 0x03, 0x59, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0a, 0x05, + 0x12, 0x03, 0x59, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0a, 0x01, 0x12, 0x03, + 0x59, 0x12, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x59, 0x2a, + 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0b, 0x12, 0x03, 0x5a, 0x04, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0b, 0x04, 0x12, 0x03, 0x5a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x0b, 0x05, 0x12, 0x03, 0x5a, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x0b, 0x01, 0x12, 0x03, 0x5a, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0b, + 0x03, 0x12, 0x03, 0x5a, 0x1a, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0c, 0x12, 0x03, + 0x5b, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0c, 0x04, 0x12, 0x03, 0x5b, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0c, 0x05, 0x12, 0x03, 0x5b, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x5b, 0x14, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x5b, 0x2a, 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x0d, 0x12, 0x03, 0x5c, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, + 0x04, 0x12, 0x03, 0x5c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x06, 0x12, + 0x03, 0x5c, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x5c, + 0x16, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x5c, 0x1e, 0x22, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0e, 0x12, 0x03, 0x5d, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x0e, 0x04, 0x12, 0x03, 0x5d, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x5d, 0x0d, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x0e, 0x01, 0x12, 0x03, 0x5d, 0x10, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0e, 0x03, + 0x12, 0x03, 0x5d, 0x15, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x02, 0x12, 0x04, 0x60, 0x00, 0x65, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x02, 0x01, 0x12, 0x03, 0x60, 0x05, 0x0f, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x02, 0x02, 0x00, 0x12, 0x03, 0x61, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x61, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x00, + 0x02, 0x12, 0x03, 0x61, 0x16, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x62, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x62, 0x04, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x01, 0x02, 0x12, 0x03, 0x62, 0x16, 0x19, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x02, 0x12, 0x03, 0x63, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x63, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x63, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x64, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x64, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x03, 0x02, 0x12, 0x03, 0x64, 0x19, + 0x1c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x67, 0x00, 0x6c, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x67, 0x08, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x68, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x68, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x68, + 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x68, 0x13, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x68, 0x19, 0x1c, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x69, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x04, 0x12, 0x03, 0x69, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x69, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x69, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x69, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x6a, 0x04, 0x1f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x03, 0x6a, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x03, 0x6a, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x6a, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x6a, 0x1b, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, + 0x12, 0x03, 0x6b, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x04, 0x12, 0x03, + 0x6b, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x05, 0x12, 0x03, 0x6b, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x03, 0x6b, 0x14, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x03, 0x6b, 0x1e, 0x21, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x06, 0x12, 0x04, 0x6e, 0x00, 0x78, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, + 0x12, 0x03, 0x6e, 0x08, 0x0a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x6f, + 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x03, 0x6f, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x6f, 0x0d, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6f, 0x13, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6f, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x01, 0x12, 0x03, 0x70, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, + 0x12, 0x03, 0x70, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x70, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x70, 0x13, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x70, 0x1d, 0x20, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, 0x71, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, 0x03, 0x71, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x71, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x71, 0x13, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x71, 0x1f, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x72, 0x04, + 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x04, 0x12, 0x03, 0x72, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x05, 0x12, 0x03, 0x72, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x03, 0x72, 0x13, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x03, 0x03, 0x12, 0x03, 0x72, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x04, 0x12, 0x03, 0x73, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, + 0x03, 0x73, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x05, 0x12, 0x03, 0x73, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x03, 0x73, 0x14, 0x1d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x03, 0x73, 0x20, 0x23, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x06, 0x02, 0x05, 0x12, 0x03, 0x74, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x05, 0x04, 0x12, 0x03, 0x74, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x05, 0x05, 0x12, 0x03, 0x74, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x74, 0x14, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x03, + 0x74, 0x25, 0x28, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x06, 0x12, 0x03, 0x75, 0x04, 0x22, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x04, 0x12, 0x03, 0x75, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x05, 0x12, 0x03, 0x75, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x06, 0x01, 0x12, 0x03, 0x75, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x06, 0x03, 0x12, 0x03, 0x75, 0x1e, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x07, + 0x12, 0x03, 0x76, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x04, 0x12, 0x03, + 0x76, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x05, 0x12, 0x03, 0x76, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x01, 0x12, 0x03, 0x76, 0x14, 0x1e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x03, 0x12, 0x03, 0x76, 0x21, 0x24, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x08, 0x12, 0x03, 0x77, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x08, 0x04, 0x12, 0x03, 0x77, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, + 0x05, 0x12, 0x03, 0x77, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x01, 0x12, + 0x03, 0x77, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x08, 0x03, 0x12, 0x03, 0x77, + 0x19, 0x1c, +]; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +}